Những chương trình này làm gì?
Hóa ra lần triển khai thứ hai chạy nhanh gấp đôi so với lần triển khai đầu tiên. Bạn có mong đợi một kết quả như vậy? bạn giải thích nó như thế nào?

Bài tập 3.15

Bạn có thể cải thiện hoặc thêm bất cứ điều gì vào tập hợp các phép toán của lớp chuỗi được đưa ra trong phần trước không? Giải thích đề xuất của bạn

3.5. thông số const

Hãy lấy ví dụ mã sau:

Vì (int chỉ mục = 0; chỉ mục< 512; ++index) ... ;

Có hai vấn đề khi sử dụng số 512. Đầu tiên là sự dễ dàng nhận thức về văn bản chương trình. Tại sao giới hạn trên của biến vòng lặp phải chính xác là 512? Điều gì ẩn đằng sau giá trị này? Cô ấy có vẻ ngẫu nhiên...
Vấn đề thứ hai liên quan đến sự dễ dàng sửa đổi và bảo trì mã. Giả sử chương trình có 10.000 dòng và số 512 xuất hiện trong 4% trong số đó. Giả sử rằng trong 80% trường hợp, số 512 phải được đổi thành 1024. Bạn có thể tưởng tượng được mức độ phức tạp của công việc đó và số lượng lỗi có thể mắc phải khi sửa sai giá trị không?
Chúng tôi giải quyết cả hai vấn đề này cùng một lúc: chúng tôi cần tạo một đối tượng có giá trị 512. Đặt cho nó một cái tên có ý nghĩa, chẳng hạn như bufSize, chúng tôi làm cho chương trình dễ hiểu hơn nhiều: rõ ràng chính xác biến vòng lặp được so sánh là gì ĐẾN.

Mục lục< bufSize

Trong trường hợp này, việc thay đổi kích thước của bufSize không yêu cầu phải xem qua 400 dòng mã để sửa đổi 320 dòng trong số đó. Khả năng xảy ra lỗi sẽ giảm đi bao nhiêu khi chỉ thêm một đối tượng! Bây giờ giá trị là 512 bản địa hóa.

Int bufSize = 512; // kích thước bộ đệm đầu vào // ... for (int chỉ mục = 0; chỉ mục< bufSize; ++index)
// ...

Vẫn còn một vấn đề nhỏ: biến bufSize ở đây là giá trị l có thể vô tình bị thay đổi trong chương trình, dẫn đến lỗi khó bắt. Đây là một lỗi phổ biến: sử dụng toán tử gán (=) thay vì toán tử so sánh (==):

// thay đổi ngẫu nhiên trong giá trị bufSize if (bufSize = 1) // ...

Việc thực thi mã này sẽ khiến giá trị bufSize trở thành 1, điều này có thể dẫn đến hành vi chương trình hoàn toàn không thể đoán trước. Những lỗi loại này thường rất khó phát hiện vì đơn giản là chúng không thể nhìn thấy được.
Sử dụng công cụ xác định const sẽ giải quyết được vấn đề này. Bằng cách khai báo đối tượng là

Const int bufSize = 512; // kích thước bộ đệm đầu vào

chúng ta biến biến thành một hằng số có giá trị 512, giá trị này không thể thay đổi: những nỗ lực như vậy bị trình biên dịch ngăn chặn: việc sử dụng sai toán tử gán thay vì so sánh, như trong ví dụ trên, sẽ gây ra lỗi biên dịch.

// lỗi: cố gắng gán giá trị cho một hằng số if (bufSize = 0) ...

Vì một hằng số không thể được gán một giá trị nên nó phải được khởi tạo tại nơi nó được xác định. Việc xác định một hằng số mà không khởi tạo nó cũng gây ra lỗi biên dịch:

Const kép pi; // lỗi: hằng số chưa được khởi tạo

Const gấp đôi mức lương tối thiểu = 9,60; // Phải? lỗi?
gấp đôi *ptr =

Trình biên dịch có nên cho phép gán như vậy không? Vì minWage là một hằng số nên nó không thể được gán một giá trị. Mặt khác, không có gì ngăn cản chúng tôi viết:

*ptr += 1,40; // thay đổi đối tượng minWage!

Theo quy định, trình biên dịch không có khả năng bảo vệ khỏi việc sử dụng con trỏ và sẽ không thể báo hiệu lỗi nếu chúng được sử dụng theo cách này. Điều này đòi hỏi phải phân tích quá sâu về logic chương trình. Do đó, trình biên dịch đơn giản cấm việc gán địa chỉ không đổi cho các con trỏ thông thường.
Vậy có phải chúng ta không có khả năng sử dụng con trỏ tới hằng số? KHÔNG. Với mục đích này, có các con trỏ được khai báo bằng mã xác định const:

Const kép *cptr;

trong đó cptr là một con trỏ tới một đối tượng có kiểu const double. Điều tinh tế là bản thân con trỏ không phải là hằng số, nghĩa là chúng ta có thể thay đổi giá trị của nó. Ví dụ:

Hằng số kép *pc = 0; const gấp đôi mức lương tối thiểu = 9,60; // đúng: chúng tôi không thể thay đổi minWage bằng pc
pc = gấp đôi dval = 3,14; // đúng: chúng tôi không thể thay đổi minWage bằng pc
// mặc dù dval không phải là hằng số
pc = // đúng dval = 3.14159; //Phải
*pc = 3,14159; // lỗi

Địa chỉ của một đối tượng không đổi chỉ được gán cho một con trỏ tới một hằng số. Đồng thời, một con trỏ như vậy cũng có thể được gán địa chỉ của một biến thông thường:

máy tính =

Một con trỏ không đổi không cho phép sửa đổi đối tượng mà nó đánh địa chỉ bằng cách sử dụng địa chỉ gián tiếp. Mặc dù dval trong ví dụ trên không phải là hằng số nhưng trình biên dịch sẽ không cho phép thay đổi dval qua máy tính. (Một lần nữa, vì nó không thể xác định địa chỉ của đối tượng nào có thể chứa con trỏ bất kỳ lúc nào trong quá trình thực hiện chương trình.)
Trong các chương trình thực, con trỏ tới hằng thường được sử dụng làm tham số hình thức của hàm. Việc sử dụng chúng đảm bảo rằng đối tượng được truyền cho một hàm dưới dạng đối số thực tế sẽ không bị hàm đó sửa đổi. Ví dụ:

// Trong các chương trình thực, con trỏ tới hằng số thường // được sử dụng làm tham số hình thức của hàm int strcmp(const char *str1, const char *str2);

(Chúng ta sẽ nói nhiều hơn về con trỏ hằng trong Chương 7 khi nói về hàm.)
Ngoài ra còn có con trỏ liên tục. (Lưu ý sự khác biệt giữa con trỏ hằng và con trỏ hằng số!). Con trỏ hằng có thể định địa chỉ của một hằng hoặc một biến. Ví dụ:

Int errNumb = 0; int *const currErr =

Ở đây curErr là một con trỏ hằng tới một đối tượng không phải là hằng. Điều này có nghĩa là chúng ta không thể gán cho nó địa chỉ của một đối tượng khác, mặc dù bản thân đối tượng đó có thể được sửa đổi. Đây là cách sử dụng con trỏ curErr:

Làm việc gì đó(); if (*curErr) (
errorHandler();
*curErr = 0; // đúng: đặt lại giá trị errNumb
}

Cố gắng gán giá trị cho con trỏ hằng sẽ gây ra lỗi biên dịch:

CurErr = // lỗi

Một con trỏ hằng tới một hằng là sự kết hợp của hai trường hợp được xem xét.

Const kép pi = 3,14159; const kép *const pi_ptr = π

Cả giá trị của đối tượng được trỏ bởi pi_ptr cũng như giá trị của chính con trỏ đều không thể thay đổi trong chương trình.

Bài tập 3.16

Giải thích ý nghĩa của 5 định nghĩa sau. Có ai trong số họ sai?

(a) int tôi; (d) int *const cpi; (b) hằng int ic; (e) const int *const cpic; (c) const int *pic;

Bài tập 3.17

Định nghĩa nào sau đây là đúng? Tại sao?

(a) int i = -1; (b) const int ic = i; (c) const int *pic = (d) int *const cpi = (e) const int *const cpic =

Bài tập 3.18

Sử dụng các định nghĩa từ bài tập trước, hãy xác định các toán tử gán chính xác. Giải thích.

(a) i = ic; (d) pic = cpic; (b) pic = (i) cpic = (c) cpi = pic; (f) ic = *cpic;

3.6. Loại tham chiếu

Loại tham chiếu, đôi khi được gọi là bí danh, được sử dụng để đặt tên bổ sung cho đối tượng. Một tham chiếu cho phép bạn thao tác một đối tượng một cách gián tiếp, giống như bạn có thể làm với một con trỏ. Tuy nhiên, thao tác gián tiếp này không yêu cầu cú pháp đặc biệt cần thiết cho con trỏ. Thông thường, các tham chiếu được sử dụng làm tham số hình thức của hàm. Trong phần này, chúng ta sẽ xem xét việc sử dụng các đối tượng kiểu tham chiếu.
Loại tham chiếu được biểu thị bằng cách chỉ định toán tử địa chỉ (&) trước tên biến. Liên kết phải được khởi tạo. Ví dụ:

Int ival = 1024; // đúng: refVal - tham chiếu tới ival int &refVal = ival; // lỗi: tham chiếu phải được khởi tạo thành int

Int ival = 1024; // lỗi: refVal thuộc loại int, không phải int* int &refVal = int *pi = // đúng: ptrVal là tham chiếu đến một con trỏ int *&ptrVal2 = pi;

Khi một tham chiếu được xác định, bạn không thể thay đổi nó để hoạt động với một đối tượng khác (đó là lý do tại sao tham chiếu phải được khởi tạo tại thời điểm nó được xác định). Trong ví dụ sau, toán tử gán không thay đổi giá trị của refVal; giá trị mới được gán cho biến ival - biến mà refVal đánh địa chỉ.

Int min_val = 0; // ival nhận giá trị của min_val, // thay vì refVal thay đổi giá trị thành min_val refVal = min_val;

Giá trị tham chiếu += 2; thêm 2 vào ival, biến được tham chiếu bởi refVal. Tương tự int ii = refVal; gán ii giá trị hiện tại của ival, int *pi = khởi tạo pi với địa chỉ của ival.

// hai đối tượng kiểu int được định nghĩa int ival = 1024, ival2 = 2048; // một tham chiếu và một đối tượng được định nghĩa int &rval = ival, rval2 = ival2; // một đối tượng, một con trỏ và một tham chiếu được xác định
int inal3 = 1024, *pi = ival3, &ri = ival3; // hai liên kết được xác định int &rval3 = ival3, &rval4 = ival2;

Một tham chiếu const có thể được khởi tạo bởi một đối tượng thuộc loại khác (tất nhiên, giả sử có thể chuyển đổi loại này sang loại khác), cũng như bằng một giá trị không có địa chỉ, chẳng hạn như hằng số bằng chữ. Ví dụ:

Giá trị kép = 3,14159; // chỉ đúng với tham chiếu hằng
const int &ir = 1024;
const int &ir2 = dval;
const kép &dr = dval + 1.0;

Nếu chúng ta không chỉ định trình xác định const thì cả ba định nghĩa tham chiếu đều có thể gây ra lỗi biên dịch. Tuy nhiên, lý do tại sao trình biên dịch không vượt qua được những định nghĩa như vậy vẫn chưa rõ ràng. Hãy cố gắng tìm ra nó.
Đối với chữ, điều này ít nhiều rõ ràng: chúng ta không thể gián tiếp thay đổi giá trị của chữ bằng cách sử dụng con trỏ hoặc tham chiếu. Đối với các đối tượng thuộc loại khác, trình biên dịch chuyển đổi đối tượng gốc thành một số đối tượng phụ trợ. Ví dụ: nếu chúng ta viết:

Giá trị kép = 1024; const int &ri = dval;

sau đó trình biên dịch chuyển đổi nó thành một cái gì đó như thế này:

Int temp = dval; const int &ri = temp;

Nếu chúng ta có thể gán một giá trị mới cho tham chiếu ri, chúng ta sẽ thực sự thay đổi không phải dval mà là temp. Giá trị dval sẽ giữ nguyên, điều này hoàn toàn không được người lập trình biết đến. Do đó, trình biên dịch cấm những hành động như vậy và cách duy nhất để khởi tạo một tham chiếu với một đối tượng thuộc loại khác là khai báo nó là const.
Đây là một ví dụ khác về một liên kết khó hiểu trong lần đầu tiên. Chúng tôi muốn xác định một tham chiếu đến địa chỉ của một đối tượng không đổi, nhưng tùy chọn đầu tiên của chúng tôi gây ra lỗi biên dịch:

Const int ival = 1024; // lỗi: cần tham chiếu liên tục
int *&pi_ref =

Nỗ lực khắc phục sự cố bằng cách thêm công cụ xác định const cũng không thành công:

Const int ival = 1024; // vẫn còn lỗi const int *&pi_ref =

Lý do là gì? Nếu đọc kỹ định nghĩa, chúng ta sẽ thấy pi_ref là một tham chiếu đến một con trỏ hằng tới một đối tượng có kiểu int. Và chúng ta cần một con trỏ không phải hằng tới một đối tượng không đổi, vì vậy mục sau đây sẽ đúng:

Const int ival = 1024; // Phải
int *const &piref =

Có hai điểm khác biệt chính giữa một liên kết và một con trỏ. Đầu tiên, liên kết phải được khởi tạo tại nơi nó được xác định. Thứ hai, bất kỳ thay đổi nào đối với một liên kết đều không biến đổi liên kết mà là đối tượng mà nó đề cập đến. Hãy xem xét các ví dụ. Nếu chúng ta viết:

Int *pi = 0;

chúng ta khởi tạo con trỏ pi về 0, nghĩa là pi không trỏ tới bất kỳ đối tượng nào. Đồng thời ghi

const int &ri = 0;
có nghĩa là một cái gì đó như thế này:
int tạm thời = 0;
const int &ri = temp;

Đối với thao tác gán, trong ví dụ sau:

Int ival = 1024, ival2 = 2048; int *pi = &ival, *pi2 = pi = pi2;

biến ival được trỏ tới bởi pi không thay đổi và pi nhận giá trị địa chỉ của biến ival2. Cả pi và pi2 hiện đều trỏ đến cùng một đối tượng, ival2.
Nếu chúng ta làm việc với các liên kết:

Int &ri = ival, &ri2 = ival2; ri = ri2;

// ví dụ về sử dụng liên kết // Giá trị được trả về trong tham số next_value
bool get_next_value(int &next_value); // toán tử quá tải Toán tử ma trận+(const Matrix&, const Matrix&);

Int ival; trong khi (get_next_value(ival)) ...

Int &next_value = ival;

(Việc sử dụng tham chiếu làm tham số hình thức của hàm sẽ được thảo luận chi tiết hơn trong Chương 7.)

Bài tập 3.19

Có sai sót nào trong các định nghĩa này không? Giải thích. Bạn sẽ sửa chúng như thế nào?

(a) int ival = 1,01; (b) int &rval1 = 1,01; (c) int &rval2 = ival; (d) int &rval3 = (e) int *pi = (f) int &rval4 = pi; (g) int &rval5 = pi*; (h) int &*prval1 = pi; (i) const int &ival2 = 1; (j) const int &*prval2 =

Bài tập 3.20

Có bất kỳ toán tử gán nào sau đây sai không (sử dụng các định nghĩa từ bài tập trước)?

(a) rval1 = 3,14159; (b) prval1 = prval2; (c) prval2 = rval1; (d) *prval2 = ival2;

Bài tập 3.21

Tìm lỗi trong các hướng dẫn đã cho:

(a) int ival = 0; const int *pi = 0; const int &ri = 0; (b)pi =
ri =
số pi =

3.7. Nhập bool

Một đối tượng kiểu bool có thể nhận một trong hai giá trị: true và false. Ví dụ:

// khởi tạo chuỗi string search_word = get_word(); // khởi tạo biến tìm thấy
bool tìm thấy = sai; chuỗi next_word; trong khi (cin >> next_word)
nếu (next_word == search_word)
tìm thấy = đúng;
// ... // viết tắt: if (tìm thấy == true)
Nếu được tìm thấy)
cout<< "ok, мы нашли слово\n";
cách khác<< "нет, наше слово не встретилось.\n";

Mặc dù bool là một trong các kiểu số nguyên nhưng nó không thể được khai báo là có dấu, không dấu, ngắn hoặc dài, vì vậy định nghĩa trên là sai:

// lỗi short bool Found = false;

Các đối tượng kiểu bool được ngầm chuyển thành kiểu int. Đúng trở thành 1 và sai trở thành 0. Ví dụ:

Bool được tìm thấy = sai; int lần xuất hiện_count = 0; trong khi (/* lầm bầm */)
{
đã tìm thấy = look_for(/* gì đó */); // giá trị tìm thấy được chuyển thành 0 hoặc 1
số lần xuất hiện += được tìm thấy; )

Theo cách tương tự, các giá trị của kiểu số nguyên và con trỏ có thể được chuyển đổi thành giá trị kiểu bool. Trong trường hợp này, 0 được hiểu là sai và mọi thứ khác đều đúng:

// trả về số lần xuất hiện extern int find(const string&); bool tìm thấy = sai; if (found = find("rosebud")) // đúng: đã tìm thấy == true // trả về một con trỏ tới phần tử
extern int* find(int value); if (found = find(1024)) // đúng: đã tìm thấy == true

3.8. chuyển nhượng

Thường thì bạn phải xác định một biến lấy các giá trị từ một tập hợp nhất định. Giả sử một tệp được mở ở bất kỳ chế độ nào trong ba chế độ: để đọc, để viết, để nối thêm.
Tất nhiên, ba hằng số có thể được định nghĩa để biểu thị các chế độ này:

Const int đầu vào = 1; const int đầu ra = 2; const int nối thêm = 3;

và sử dụng các hằng số này:

Bool open_file(chuỗi file_name, int open_mode); // ...
open_file("Phoenix_and_the_Crane", nối thêm);

Giải pháp này có thể thực hiện được nhưng không hoàn toàn chấp nhận được vì chúng tôi không thể đảm bảo rằng đối số được truyền cho hàm open_file() chỉ là 1, 2 hoặc 3.
Sử dụng loại enum sẽ giải quyết được vấn đề này. Khi chúng tôi viết:

Enum open_modes(đầu vào = 1, đầu ra, nối thêm);

chúng tôi xác định một loại open_modes mới. Các giá trị hợp lệ cho một đối tượng thuộc loại này được giới hạn ở tập hợp 1, 2 và 3, với mỗi giá trị được chỉ định có một tên dễ nhớ. Chúng ta có thể sử dụng tên của loại mới này để xác định cả đối tượng của loại đó và loại tham số hình thức của hàm:

Void open_file(string file_name, open_modes om);

đầu vào, đầu ra và nối thêm là phần tử liệt kê. Tập hợp các phần tử liệt kê chỉ định tập giá trị được phép cho một đối tượng thuộc một loại nhất định. Một biến kiểu open_modes (trong ví dụ của chúng tôi) được khởi tạo với một trong các giá trị này; nó cũng có thể được gán bất kỳ giá trị nào trong số đó. Ví dụ:

Open_file("Phượng Hoàng và Sếu", nối thêm);

Việc cố gắng gán một giá trị không phải là một trong các phần tử liệt kê cho một biến thuộc loại này (hoặc chuyển nó dưới dạng tham số cho hàm) sẽ gây ra lỗi biên dịch. Ngay cả khi chúng ta cố gắng truyền một giá trị số nguyên tương ứng với một trong các phần tử liệt kê, chúng ta vẫn sẽ nhận được lỗi:

// lỗi: 1 không phải là thành phần của bảng liệt kê open_modes open_file("Jonah", 1);

Có một cách để xác định một biến kiểu open_modes, gán cho nó giá trị của một trong các phần tử liệt kê và truyền nó dưới dạng tham số cho hàm:

Open_modes om = đầu vào; // ... om = nối thêm; open_file("TailTell", om);

Tuy nhiên, không thể có được tên của các yếu tố đó. Nếu chúng ta viết câu lệnh đầu ra:

cout<< input << " " << om << endl;

thì chúng ta vẫn nhận được:

Vấn đề này được giải quyết bằng cách xác định một mảng chuỗi trong đó phần tử có chỉ số bằng giá trị của phần tử liệt kê sẽ chứa tên của nó. Cho một mảng như vậy, chúng ta có thể viết:

cout<< open_modes_table[ input ] << " " << open_modes_table[ om ] << endl Будет выведено: input append

Ngoài ra, bạn không thể lặp qua tất cả các giá trị của một enum:

// không được hỗ trợ cho (open_modes iter = input; iter != nối thêm; ++inter) // ...

Để xác định một bảng liệt kê, hãy sử dụng từ khóa enum và tên thành phần được chỉ định trong dấu ngoặc nhọn, phân tách bằng dấu phẩy. Theo mặc định, giá trị đầu tiên là 0, giá trị tiếp theo là 1, v.v. Bạn có thể thay đổi quy tắc này bằng toán tử gán. Trong trường hợp này, mỗi phần tử tiếp theo không có giá trị được chỉ định rõ ràng sẽ nhiều hơn phần tử đứng trước nó trong danh sách 1 đơn vị. Trong ví dụ của chúng tôi, chúng tôi đã chỉ định rõ ràng giá trị 1 cho đầu vào, còn đầu ra và phần bổ sung sẽ bằng 2 và 3. Đây là một ví dụ khác:

// hình dạng == 0, hình cầu == 1, hình trụ == 2, đa giác == 3 enum Các dạng( chia sẻ, hình tròn, hình trụ, đa giác);

Các giá trị nguyên tương ứng với các phần tử khác nhau của cùng một bảng liệt kê không nhất thiết phải khác nhau. Ví dụ:

// point2d == 2, point2w == 3, point3d == 3, point3w == 4 enum Điểm ( point2d=2, point2w, point3d=3, point3w=4 );

Một đối tượng có kiểu liệt kê có thể được xác định, sử dụng trong các biểu thức và được truyền cho hàm dưới dạng đối số. Một đối tượng như vậy được khởi tạo chỉ với giá trị của một trong các phần tử liệt kê và chỉ giá trị đó được gán cho nó, rõ ràng hoặc là giá trị của một đối tượng khác cùng loại. Ngay cả các giá trị số nguyên tương ứng với các phần tử liệt kê hợp lệ cũng không thể được gán cho nó:

Void mumble() ( Điểm pt3d = point3d; // đúng: pt2d == 3 // lỗi: pt3w được khởi tạo với kiểu int Điểm pt3w = 3; // lỗi: đa giác không được bao gồm trong bảng liệt kê Điểm pt3w = đa giác; / /đúng: cả hai đối tượng thuộc loại Points pt3w = pt3d )

Tuy nhiên, trong các biểu thức số học, một phép liệt kê có thể được tự động chuyển thành kiểu int. Ví dụ:

Const int array_size = 1024; // đúng: pt2w được chuyển thành int
int chunk_size = array_size * pt2w;

3.9. Nhập "mảng"

Chúng ta đã đề cập đến mảng trong phần 2.1. Mảng là một tập hợp các phần tử cùng kiểu, được truy cập bằng chỉ mục - số thứ tự của phần tử trong mảng. Ví dụ:

Int ival;

định nghĩa ival là một biến int và lệnh

Int ia[ 10 ];

chỉ định một mảng gồm mười đối tượng kiểu int. Đối với mỗi đối tượng này, hoặc phần tử mảng, có thể được truy cập bằng thao tác chỉ mục:

Ival = ia[ 2 ];

gán cho biến ival giá trị của phần tử mảng ia với chỉ số 2. Tương tự

Ia[ 7 ] = ival;

gán cho phần tử ở chỉ số 7 giá trị ival.

Một định nghĩa mảng bao gồm một bộ xác định kiểu, tên mảng và kích thước. Kích thước chỉ định số phần tử mảng (ít nhất là 1) và được đặt trong dấu ngoặc vuông. Kích thước của mảng phải được biết ở giai đoạn biên dịch và do đó nó phải là một biểu thức không đổi, mặc dù nó không nhất thiết phải được chỉ định dưới dạng chữ. Dưới đây là ví dụ về định nghĩa mảng đúng và sai:

Extern int get_size(); // hằng số buf_size và max_files
const int buf_size = 512, max_files = 20;
int Staff_size = 27; // đúng: hằng số char input_buffer[ buf_size ]; // đúng: biểu thức hằng số: 20 - 3 char *fileTable[ max_files-3 ]; // lỗi: không phải lương gấp đôi cố định[ Staff_size ]; // lỗi: không phải là biểu thức hằng int test_scores[ get_size() ];

Các đối tượng buf_size và max_files là các hằng số, do đó các định nghĩa mảng input_buffer và fileTable là chính xác. Nhưng kích thước nhân viên là một biến (mặc dù được khởi tạo bằng hằng số 27), có nghĩa là mức lương không được chấp nhận. (Trình biên dịch không thể tìm thấy giá trị của biến Staff_size khi mảng lương được xác định.)
Biểu thức max_files-3 có thể được đánh giá tại thời điểm biên dịch, do đó định nghĩa mảng fileTable có cú pháp chính xác.
Việc đánh số phần tử bắt đầu từ 0, do đó, đối với một mảng gồm 10 phần tử, phạm vi chỉ số chính xác không phải là 1 – 10 mà là 0 – 9. Dưới đây là ví dụ về việc lặp qua tất cả các phần tử của mảng:

Int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 0; ix< array_size; ++ ix)
ia[ix] = ix;
}

Khi xác định một mảng, bạn có thể khởi tạo nó một cách rõ ràng bằng cách liệt kê các giá trị của các phần tử của nó trong dấu ngoặc nhọn, cách nhau bằng dấu phẩy:

Const int array_size = 3; int ia[ array_size ] = ( 0, 1, 2 );

Nếu chúng ta chỉ định rõ ràng danh sách các giá trị, chúng ta không phải chỉ định kích thước của mảng: chính trình biên dịch sẽ đếm số phần tử:

// mảng có kích thước 3 int ia = ( 0, 1, 2 );

Khi cả kích thước và danh sách các giá trị đều được chỉ định rõ ràng, có thể có ba tùy chọn. Nếu kích thước và số lượng giá trị trùng nhau thì mọi thứ đều rõ ràng. Nếu danh sách các giá trị ngắn hơn kích thước đã chỉ định thì các phần tử mảng còn lại sẽ được khởi tạo về 0. Nếu có nhiều giá trị hơn trong danh sách, trình biên dịch sẽ hiển thị thông báo lỗi:

// ia ==> ( 0, 1, 2, 0, 0 ) const int array_size = 5; int ia[ array_size ] = ( 0, 1, 2 );

Một mảng ký tự có thể được khởi tạo không chỉ bằng danh sách các giá trị ký tự trong dấu ngoặc nhọn mà còn bằng một chuỗi ký tự. Tuy nhiên, có một số khác biệt giữa các phương pháp này. Hãy cùng nói nào

Const char cal = ("C", "+", "+" ); const char cal2 = "C++";

Kích thước của mảng ca1 là 3, mảng ca2 là 4 (trong chuỗi ký tự, ký tự null kết thúc được tính đến). Định nghĩa sau đây sẽ gây ra lỗi biên dịch:

// lỗi: chuỗi "Daniel" gồm 7 phần tử const char ch3[ 6 ] = "Daniel";

Một mảng không thể được gán giá trị của một mảng khác và không được phép khởi tạo một mảng bằng một mảng khác. Ngoài ra, không được phép sử dụng một loạt các tài liệu tham khảo. Dưới đây là ví dụ về cách sử dụng mảng đúng và sai:

Const int array_size = 3; int ix, jx, kx; // đúng: mảng con trỏ kiểu int* int *iar = ( &ix, &jx, &kx ); // lỗi: mảng tham chiếu không được phép int &iar = ( ix, jx, kx ); int chính()
{
int ia3( array_size ]; // đúng
// lỗi: mảng tích hợp không thể sao chép được
ia3 = ia;
trả về 0;
}

Để sao chép mảng này sang mảng khác, bạn phải thực hiện việc này cho từng phần tử riêng biệt:

Const int array_size = 7; int ia1 = ( 0, 1, 2, 3, 4, 5, 6 ); int chính() (
int ia3[kích thước mảng]; vì (int ix = 0; ix< array_size; ++ix)
ia2[ ix ] = ia1[ ix ]; trả về 0;
}

Chỉ mục mảng có thể là bất kỳ biểu thức nào tạo ra kết quả là kiểu số nguyên. Ví dụ:

Int someVal, get_index(); ia2[ get_index() ] = someVal;

Chúng tôi nhấn mạnh rằng ngôn ngữ C++ không cung cấp khả năng kiểm soát các chỉ mục mảng, ở giai đoạn biên dịch hoặc ở giai đoạn chạy. Bản thân lập trình viên phải đảm bảo chỉ số không vượt ra ngoài ranh giới của mảng. Lỗi khi làm việc với chỉ mục là khá phổ biến. Thật không may, không khó lắm để tìm thấy các ví dụ về các chương trình biên dịch và thậm chí hoạt động, nhưng vẫn chứa những lỗi nghiêm trọng sớm hay muộn dẫn đến sự cố.

Bài tập 3.22

Định nghĩa mảng nào sau đây là sai? Giải thích.

(a) int ia[ buf_size ]; (d) int ia[ 2 * 7 - 14 ] (b) int ia[ get_size() ]; (e) char st[ 11 ] = "cơ bản"; (c) int ia[ 4 * 7 - 14 ];

Bài tập 3.23

Đoạn mã sau phải khởi tạo từng phần tử của mảng bằng một giá trị chỉ mục. Tìm những lỗi mắc phải:

Int main() ( const int array_size = 10; int ia[ array_size ]; for (int ix = 1; ix<= array_size; ++ix)
ia[ ia ] = ix; // ...
}

3.9.1. Mảng đa chiều

Trong C++ có thể sử dụng mảng nhiều chiều, khi khai báo chúng phải chỉ ra ranh giới bên phải của mỗi chiều trong dấu ngoặc vuông riêng biệt. Sau đây là định nghĩa của mảng hai chiều:

Int ia[ 4 ][ 3 ];

Giá trị đầu tiên (4) chỉ định số hàng, giá trị thứ hai (3) – số cột. Đối tượng ia được định nghĩa là một mảng gồm bốn chuỗi, mỗi chuỗi có ba phần tử. Mảng đa chiều cũng có thể được khởi tạo:

Int ia[ 4 ][ 3 ] = ( ( 0, 1, 2 ), ( 3, 4, 5 ), ( 6, 7, 8 ), ( 9, 10, 11 ) );

Các dấu ngoặc nhọn bên trong, dùng để chia danh sách các giá trị thành các dòng, là tùy chọn và thường được sử dụng để làm cho mã dễ đọc hơn. Việc khởi tạo bên dưới hoàn toàn giống với ví dụ trước, mặc dù nó kém rõ ràng hơn:

Int ia = ( 0,1,2,3,4,5,6,7,8,9,10,11 );

Định nghĩa sau đây chỉ khởi tạo các phần tử đầu tiên của mỗi dòng. Các phần tử còn lại sẽ bằng 0:

Int ia[ 4 ][ 3 ] = ( (0), (3), (6), (9) );

Nếu bạn bỏ qua dấu ngoặc nhọn bên trong thì kết quả sẽ hoàn toàn khác. Tất cả ba phần tử của hàng đầu tiên và phần tử đầu tiên của hàng thứ hai sẽ nhận được giá trị được chỉ định và phần tử còn lại sẽ được khởi tạo ngầm thành 0.

Int ia[ 4 ][ 3 ] = ( 0, 3, 6, 9 );

Khi truy cập các phần tử của mảng nhiều chiều, bạn phải sử dụng chỉ mục cho từng chiều (chúng được đặt trong dấu ngoặc vuông). Đây là cách khởi tạo một mảng hai chiều bằng cách sử dụng các vòng lặp lồng nhau:

Int main() ( const int rowSize = 4; const int colSize = 3; int ia[ rowSize ][ colSize ]; for (int = 0; i< rowSize; ++i)
vì (int j = 0; j< colSize; ++j)
ia[ i ][ j ] = i + j j;
}

Thiết kế

Ia[ 1, 2 ]

là hợp lệ theo quan điểm của cú pháp C++, nhưng nó hoàn toàn không có nghĩa là điều mà một lập trình viên thiếu kinh nghiệm mong đợi. Đây không phải là khai báo mảng 1 x 2 hai chiều. Tổng hợp trong dấu ngoặc vuông là danh sách các biểu thức được phân tách bằng dấu phẩy sẽ dẫn đến giá trị cuối cùng là 2 (xem toán tử dấu phẩy trong Phần 4.2). Do đó khai báo ia tương đương với ia. Đây là một cơ hội khác để phạm sai lầm.

3.9.2. Mối quan hệ giữa mảng và con trỏ

Nếu chúng ta có một định nghĩa mảng:

Int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );

vậy thì việc chỉ nêu tên anh ấy trong chương trình có nghĩa là gì?

Sử dụng mã định danh mảng trong chương trình tương đương với việc chỉ định địa chỉ của phần tử đầu tiên:

Tương tự, bạn có thể truy cập giá trị của phần tử đầu tiên của mảng theo hai cách:

// cả hai biểu thức đều trả về phần tử đầu tiên *ia; ia;

Để lấy địa chỉ của phần tử thứ hai của mảng, chúng ta phải viết:

Như chúng tôi đã đề cập trước đó, biểu thức

cũng cung cấp địa chỉ của phần tử thứ hai của mảng. Theo đó, ý nghĩa của nó được trao cho chúng ta theo hai cách sau:

*(ia+1); ia;

Lưu ý sự khác biệt trong biểu thức:

*ia+1 và *(ia+1);

Hoạt động dereference có hiệu suất cao hơn một ưu tiên hơn hoạt động bổ sung (ưu tiên của nhà điều hành được thảo luận trong Phần 4.13). Do đó, biểu thức đầu tiên trước tiên sẽ hủy tham chiếu biến ia và lấy phần tử đầu tiên của mảng, sau đó thêm 1 vào biểu thức thứ hai mang lại giá trị của phần tử thứ hai.

Bạn có thể duyệt mảng bằng cách sử dụng chỉ mục, như chúng ta đã làm ở phần trước hoặc sử dụng con trỏ. Ví dụ:

#bao gồm int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); int *pbegin = ia; int *pend = ia + 9; while (pbegin != pend) ( cout<< *pbegin <<; ++pbegin; } }

Con trỏ pbegin được khởi tạo bằng địa chỉ của phần tử đầu tiên của mảng. Mỗi lần đi qua vòng lặp sẽ tăng con trỏ này lên 1, nghĩa là nó được dịch chuyển sang phần tử tiếp theo. Làm thế nào để bạn biết nơi để ở? Trong ví dụ của chúng tôi, chúng tôi đã xác định một con trỏ pend thứ hai và khởi tạo nó với địa chỉ theo sau phần tử cuối cùng của mảng ia. Ngay khi giá trị của pbegin bằng với pend, chúng ta biết rằng mảng đã kết thúc. Hãy viết lại chương trình này để phần đầu và phần cuối của mảng được truyền dưới dạng tham số cho một hàm tổng quát nhất định có thể in một mảng có kích thước bất kỳ:

#bao gồm void ia_print(int *pbegin, int *pend) (
trong khi (pbegin != chờ) (
cout<< *pbegin << " ";
++ bắt đầu;
}
) int chính()
{
int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 );
ia_print(ia, ia + 9);
}

Hàm của chúng ta đã trở nên phổ biến hơn, tuy nhiên, nó chỉ có thể hoạt động với các mảng kiểu int. Có một cách để loại bỏ hạn chế này: chuyển hàm này thành một mẫu (các mẫu đã được giới thiệu ngắn gọn ở phần 2.5):

#bao gồm bản mẫu void print(elemType *pbegin, elemType *pend) ( while (pbegin != pend) ( cout<< *pbegin << " "; ++pbegin; } }

Bây giờ chúng ta có thể gọi hàm print() để in các mảng thuộc bất kỳ loại nào:

Int main() ( int ia = ( 0, 1, 1, 2, 3, 5, 8, 13, 21 ); double da = ( 3.14, 6.28, 12.56, 25.12 ); chuỗi sa = ("heo con", " eeyore", "pooh" ); print(ia, ia+9);
print(da, da+4);
in(sa, sa+3);
}

Chúng tôi đã viết khái quát chức năng. Thư viện chuẩn cung cấp một tập hợp các thuật toán chung (chúng tôi đã đề cập đến điều này trong Phần 3.4) được triển khai theo cách tương tự. Các tham số của các hàm như vậy là các con trỏ tới đầu và cuối của mảng mà chúng thực hiện các hành động nhất định. Ví dụ: đây là cách gọi một thuật toán sắp xếp tổng quát trông như sau:

#bao gồm int main() ( int ia = ( 107, 28, 3, 47, 104, 76 ); chuỗi sa = ("piglet", "eeyore", "pooh" );sort(ia, ia+6);
sắp xếp(sa, sa+3);
};

(Chúng ta sẽ đi vào chi tiết hơn về các thuật toán tổng quát trong Chương 12; Phụ lục sẽ đưa ra ví dụ về cách sử dụng chúng.)
Thư viện chuẩn C++ chứa một tập hợp các lớp gói gọn việc sử dụng các vùng chứa và con trỏ. (Điều này đã được thảo luận trong Phần 2.8.) Trong phần tiếp theo, chúng ta sẽ xem xét vectơ loại vùng chứa tiêu chuẩn, đây là một triển khai hướng đối tượng của một mảng.

3.10. Lớp vectơ

Sử dụng lớp vectơ (xem Phần 2.8) là một cách thay thế cho việc sử dụng các mảng có sẵn. Lớp này cung cấp nhiều chức năng hơn nên việc sử dụng nó là thích hợp hơn. Tuy nhiên, có những tình huống mà bạn không thể thực hiện nếu không có mảng kiểu tích hợp sẵn. Một trong những tình huống này là việc xử lý các tham số dòng lệnh được truyền vào chương trình, điều mà chúng ta sẽ thảo luận trong phần 7.8. Lớp vectơ, giống như lớp chuỗi, là một phần của thư viện chuẩn C++.
Để sử dụng vectơ, bạn phải bao gồm tệp tiêu đề:

#bao gồm

Có hai cách tiếp cận hoàn toàn khác nhau để sử dụng vectơ, hãy gọi chúng là thành ngữ mảng và thành ngữ STL. Trong trường hợp đầu tiên, một đối tượng vectơ được sử dụng theo cách giống hệt như một mảng có sẵn. Một vectơ có kích thước nhất định được xác định:

Vectơ< int >ivec(10);

tương tự như việc xác định một mảng có kiểu tích hợp:

Int ia[ 10 ];

Để truy cập các phần tử riêng lẻ của một vectơ, thao tác chỉ mục được sử dụng:

Void simp1e_examp1e() ( const int e1em_size = 10; vector< int >ivec(e1em_size); int ia[ e1em_size ]; vì (int ix = 0; ix< e1em_size; ++ix)
ia[ ix ] = ivec[ ix ]; // ...
}

Chúng ta có thể tìm ra kích thước của vectơ bằng hàm size() và kiểm tra xem vectơ có trống hay không bằng hàm Empty(). Ví dụ:

Void print_vector(vector ivec) ( if (ivec.empty()) return; for (int ix=0; ix< ivec.size(); ++ix)
cout<< ivec[ ix ] << " ";
}

Các phần tử của vectơ được khởi tạo với giá trị mặc định. Đối với các kiểu số và con trỏ, giá trị này là 0. Nếu các phần tử là đối tượng lớp, thì bộ khởi tạo cho chúng được chỉ định bởi hàm tạo mặc định (xem phần 2.3). Tuy nhiên, trình khởi tạo cũng có thể được chỉ định rõ ràng bằng cách sử dụng biểu mẫu:

Vectơ< int >ivec(10, -1);

Tất cả mười phần tử của vectơ sẽ bằng -1.
Một mảng thuộc loại dựng sẵn có thể được khởi tạo rõ ràng bằng một danh sách:

Int ia[ 6 ] = ( -2, -1, O, 1, 2, 1024 );

Một hành động tương tự không thể thực hiện được đối với một đối tượng thuộc lớp vectơ. Tuy nhiên, một đối tượng như vậy có thể được khởi tạo bằng cách sử dụng kiểu mảng có sẵn:

// 6 phần tử ia được sao chép vào vector ivec< int >ivec(ia, ia+6);

Hàm tạo của vectơ ivec được truyền vào hai con trỏ - một con trỏ tới phần đầu của mảng ia và tới phần tử theo sau phần tử cuối cùng. Là danh sách các giá trị ban đầu, được phép chỉ định không phải toàn bộ mảng mà là một phạm vi nhất định của nó:

// 3 phần tử được sao chép: ia, ia, ia vector< int >ivec(&ia[ 2 ], &ia[ 5 ]);

Một điểm khác biệt giữa vectơ và mảng tích hợp là khả năng khởi tạo một đối tượng vectơ với một đối tượng vectơ khác và sử dụng toán tử gán để sao chép đối tượng. Ví dụ:

Vectơ< string >svec; void init_and_sign() ( // một vectơ được khởi tạo bởi một vectơ khác< string >user_names(svec); // ... // một vectơ được sao chép sang một vectơ khác
svec = tên_người_dùng;
}

Khi chúng ta nói về thành ngữ STL, chúng tôi muốn nói đến một cách tiếp cận hoàn toàn khác khi sử dụng vectơ. Thay vì chỉ định ngay kích thước mong muốn, chúng tôi xác định một vectơ trống:

Vectơ< string >chữ;

Sau đó, chúng tôi thêm các phần tử vào nó bằng nhiều chức năng khác nhau. Ví dụ: hàm push_back() chèn một phần tử vào cuối vectơ. Đây là một đoạn mã đọc một chuỗi các dòng từ đầu vào tiêu chuẩn và thêm chúng vào một vectơ:

Chuỗi từ; while (cin >> word) ( text.push_back(word); // ... )

Mặc dù chúng ta có thể sử dụng thao tác chỉ mục để lặp lại các phần tử của vectơ:

cout<< "считаны слова: \n"; for (int ix =0; ix < text.size(); ++ix) cout << text[ ix ] << " "; cout << endl;

Điển hình hơn trong thành ngữ này là sử dụng các trình vòng lặp:

cout<< "считаны слова: \n"; for (vector::iterator it = text.begin(); nó != text.end(); ++nó) cout<< *it << " "; cout << endl;

Trình vòng lặp là một lớp thư viện tiêu chuẩn về cơ bản là một con trỏ tới một phần tử mảng.
Sự biểu lộ

hủy đăng ký iterator và đưa ra chính phần tử vectơ. Hướng dẫn

Di chuyển con trỏ tới phần tử tiếp theo. Không cần thiết phải kết hợp hai cách tiếp cận này. Nếu bạn làm theo thành ngữ STL khi xác định một vectơ trống:

Vectơ ivec;

Sẽ là sai lầm nếu viết:

Chúng ta chưa có một phần tử nào của vectơ ivec; Số phần tử được xác định bằng hàm size().

Sai lầm ngược lại cũng có thể được thực hiện. Ví dụ: nếu chúng ta xác định một vectơ có kích thước nào đó:

Vectơ ia(10);

Sau đó, việc chèn các phần tử sẽ tăng kích thước của nó, thêm các phần tử mới vào các phần tử hiện có. Mặc dù điều này có vẻ hiển nhiên, nhưng một lập trình viên mới vào nghề có thể viết:

Const kích thước int = 7; int ia[kích thước] = ( 0, 1, 1, 2, 3, 5, 8 ); vectơ< int >ivec(kích thước); vì (int ix = 0; ix< size; ++ix) ivec.push_back(ia[ ix ]);

Điều này có nghĩa là khởi tạo vectơ ivec với các giá trị của các phần tử ia, dẫn đến vectơ ivec có kích thước 14.
Theo thành ngữ STL, bạn không chỉ có thể thêm mà còn có thể xóa các phần tử khỏi một vectơ. (Chúng ta sẽ xem xét tất cả những điều này một cách chi tiết và với các ví dụ ở Chương 6.)

Bài tập 3.24

Có sai sót nào trong các định nghĩa sau đây không?
int ia[ 7 ] = ( 0, 1, 1, 2, 3, 5, 8 );

(a) vectơ< vector< int >>ivec;
(b) vectơ< int >ivec = ( 0, 1, 1, 2, 3, 5, 8 );
(c)vectơ< int >ivec(ia, ia+7);
(d)vectơ< string >svec = ivec;
(e)vectơ< string >svec(10, string("null"));

Bài tập 3.25

Thực hiện chức năng sau:
bool is_equal(const int*ia, int ia_size,
vectơ hằng &ivec);
Hàm is_equal() so sánh hai phần tử vùng chứa theo từng phần tử. Trong trường hợp các thùng chứa có kích thước khác nhau, "đuôi" của thùng dài hơn không được tính đến. Rõ ràng là nếu tất cả các phần tử được so sánh đều bằng nhau thì hàm trả về true, nếu ít nhất một phần tử khác thì trả về false. Sử dụng một iterator để lặp qua các phần tử. Viết hàm main() gọi is_equal().

3.11. lớp học phức tạp

Lớp số phức phức là một lớp khác trong thư viện chuẩn. Như thường lệ, để sử dụng nó, bạn cần bao gồm tệp tiêu đề:

#bao gồm

Một số phức bao gồm hai phần - thực và ảo. Phần ảo là căn bậc hai của một số âm. Số phức thường được viết dưới dạng

trong đó 2 là phần thực và 3i là phần ảo. Dưới đây là ví dụ về định nghĩa của các đối tượng thuộc loại phức tạp:

// số thuần ảo: 0 + 7-i phức< double >nguyên chất(0, 7); // phần ảo là 0:3 + phức Oi< float >rea1_num(3); // cả phần thực và phần ảo đều bằng 0: 0 + 0-i phức< long double >số không; // khởi tạo một số phức với một số phức khác< double >purei2(purei);

Vì phức tạp, giống như vectơ, là một mẫu nên chúng ta có thể khởi tạo nó bằng các kiểu float, double và long double, như trong các ví dụ đã cho. Bạn cũng có thể định nghĩa một mảng các phần tử có kiểu phức tạp:

Tổ hợp< double >liên hợp[2] = (phức tạp< double >(2, 3), phức tạp< double >(2, -3) };

Tổ hợp< double >*ptr = phức tạp< double >&ref = *ptr;

3.12. chỉ thị typedef

Lệnh typedef cho phép bạn chỉ định từ đồng nghĩa cho kiểu dữ liệu tùy chỉnh hoặc tích hợp. Ví dụ:

Typedef lương gấp đôi; vectơ typedef vec_int; typedef vec_int test_scores; typedef bool in_attendance; typedef int *Pint;

Các tên được xác định bằng chỉ thị typedef có thể được sử dụng giống như cách xác định kiểu:

// gấp đôi mỗi giờ, hàng tuần; lương theo giờ, hàng tuần; //vectơ vecl(10);
vec_int vecl(10); //vectơ test0(c1ass_size); const int c1ass_size = 34; test_scores test0(c1ass_size); //vectơ< bool >sự tham dự; vectơ< in_attendance >tham dự(c1ass_size); // int *bảng[ 10 ]; Bàn pint [10];

Lệnh này bắt đầu bằng từ khóa typedef, theo sau là một công cụ xác định loại và kết thúc bằng một mã định danh, trở thành từ đồng nghĩa với loại đã chỉ định.
Tên được xác định bằng lệnh typedef được sử dụng để làm gì? Bằng cách sử dụng tên dễ nhớ cho các kiểu dữ liệu, bạn có thể làm cho chương trình của mình dễ hiểu hơn. Ngoài ra, người ta thường sử dụng những tên như vậy cho các kiểu hỗn hợp phức tạp khó hiểu (xem ví dụ ở Phần 3.14), để khai báo các con trỏ tới các hàm và hàm thành viên của một lớp (xem Phần 13.6).
Dưới đây là ví dụ về một câu hỏi mà hầu hết mọi người đều trả lời sai. Lỗi xảy ra do hiểu nhầm lệnh typedef là sự thay thế macro văn bản đơn giản. Định nghĩa đã cho:

Typedef char *cstring;

Kiểu của biến cstr trong khai báo sau là gì:

bên ngoài const cstring cstr;

Câu trả lời có vẻ hiển nhiên là:

Const char *ctr

Tuy nhiên, điều này là không đúng sự thật. Công cụ xác định const đề cập đến cstr, vì vậy câu trả lời đúng là một con trỏ const tới char:

Char *const cstr;

3.13. công cụ xác định dễ bay hơi

Một đối tượng được khai báo là không ổn định nếu giá trị của nó có thể thay đổi mà trình biên dịch không nhận thấy, chẳng hạn như một biến được đồng hồ hệ thống cập nhật. Trình xác định này cho trình biên dịch biết rằng nó không cần tối ưu hóa mã để hoạt động với đối tượng này.
Công cụ xác định dễ bay hơi được sử dụng tương tự như công cụ xác định const:

Dễ bay hơi int disp1ay_register; Nhiệm vụ dễ bay hơi *curr_task; int dễ bay hơi ixa[ max_size ]; Màn hình dễ bay hơi bitmap_buf;

display_register là một đối tượng dễ thay đổi kiểu int. curr_task là một con trỏ tới một đối tượng dễ bay hơi của lớp Task. ixa là một mảng số nguyên không ổn định và mỗi phần tử của mảng đó được coi là không ổn định. bitmap_buf là một đối tượng dễ bay hơi của lớp Screen, mỗi thành viên dữ liệu của nó cũng được coi là dễ bay hơi.
Mục đích duy nhất của việc sử dụng công cụ xác định dễ bay hơi là để báo cho trình biên dịch biết rằng nó không thể xác định ai có thể thay đổi giá trị của một đối tượng nhất định và bằng cách nào. Do đó, trình biên dịch không nên thực hiện tối ưu hóa mã sử dụng đối tượng này.

3.14. Cặp lớp

Lớp pair của thư viện chuẩn C++ cho phép chúng ta định nghĩa một cặp giá trị với một đối tượng nếu có bất kỳ kết nối ngữ nghĩa nào giữa chúng. Các giá trị này có thể giống nhau hoặc khác loại. Để sử dụng lớp này, bạn phải bao gồm tệp tiêu đề:

#bao gồm

Ví dụ, hướng dẫn

Đôi< string, string >tác giả("James", "Joyce");

tạo một đối tượng tác giả kiểu cặp, bao gồm hai giá trị chuỗi.
Các phần riêng lẻ của một cặp có thể thu được bằng cách sử dụng thành viên thứ nhất và thứ hai:

Chuỗi sách đầu tiên; if (Joyce.first == "James" &&
Joyce.second == "Joyce")
firstBook = "Anh hùng Stephen";

Nếu bạn cần định nghĩa một số đối tượng cùng loại của lớp này, sẽ thuận tiện hơn khi sử dụng chỉ thị typedef:

cặp Typedef< string, string >Tác giả; Tác giả proust("marcel", "proust"); Tác giả joyce("James", "Joyce"); Tác giả musil("robert", "musi1");

Đây là một ví dụ khác về việc sử dụng một cặp. Giá trị đầu tiên chứa tên của một đối tượng nào đó, giá trị thứ hai là một con trỏ tới thành phần bảng tương ứng với đối tượng này.

Khe đầu vào lớp; extern EntrySlot* 1ook_up(string); cặp typedef< string, EntrySlot* >Biểu tượngEntry; SymbolEntry current_entry("tác giả", 1ook_up("tác giả"));
// ... if (EntrySlot *it = 1ook_up("editor")) (
current_entry.first = "biên tập viên";
current_entry.second = nó;
}

(Chúng ta sẽ quay lại lớp cặp khi nói về các loại vùng chứa trong Chương 6 và về các thuật toán chung trong Chương 12.)

3.15. Các loại lớp

Cơ chế lớp cho phép bạn tạo các kiểu dữ liệu mới; với sự trợ giúp của nó, các kiểu chuỗi, vectơ, phức và cặp được thảo luận ở trên đã được giới thiệu. Trong Chương 2, chúng tôi đã giới thiệu các khái niệm và cơ chế hỗ trợ các cách tiếp cận đối tượng và hướng đối tượng, sử dụng ví dụ về cách triển khai lớp Array. Ở đây, dựa trên cách tiếp cận đối tượng, chúng ta sẽ tạo một lớp String đơn giản, việc triển khai lớp này sẽ giúp chúng ta hiểu, cụ thể là nạp chồng toán tử - chúng ta đã nói về nó trong phần 2.3. (Các lớp được trình bày chi tiết trong Chương 13, 14 và 15.) Chúng tôi đã đưa ra một mô tả ngắn gọn về lớp học để đưa ra những ví dụ thú vị hơn. Người đọc mới làm quen với C++ có thể muốn bỏ qua phần này và chờ mô tả các lớp có hệ thống hơn trong các chương sau.)
Lớp String của chúng ta phải hỗ trợ khởi tạo bởi một đối tượng của lớp String, một chuỗi ký tự và một kiểu chuỗi tích hợp cũng như thao tác gán giá trị cho các kiểu này. Chúng tôi sử dụng các hàm tạo của lớp và toán tử gán được nạp chồng cho việc này. Việc truy cập vào các ký tự Chuỗi riêng lẻ sẽ được triển khai dưới dạng thao tác lập chỉ mục quá tải. Ngoài ra, chúng ta sẽ cần: hàm size() để lấy thông tin về độ dài của chuỗi; hoạt động so sánh các đối tượng thuộc loại Chuỗi và đối tượng Chuỗi với một chuỗi thuộc loại có sẵn; cũng như các hoạt động I/O của đối tượng của chúng ta. Cuối cùng, chúng tôi triển khai khả năng truy cập vào biểu diễn bên trong của chuỗi dưới dạng loại chuỗi tích hợp.
Định nghĩa lớp bắt đầu bằng từ khóa class, theo sau là mã định danh—tên của lớp hoặc loại. Nói chung, một lớp bao gồm các phần được đặt trước bởi các từ public (mở) và riêng tư (đóng). Phần công khai thường chứa một tập hợp các thao tác được lớp hỗ trợ, được gọi là các phương thức hoặc hàm thành viên của lớp. Các hàm thành viên này xác định giao diện chung của lớp, hay nói cách khác là tập hợp các hành động có thể được thực hiện trên các đối tượng của lớp đó. Phần riêng tư thường bao gồm các thành viên dữ liệu cung cấp khả năng triển khai nội bộ. Trong trường hợp của chúng tôi, các thành viên bên trong bao gồm _string - một con trỏ tới một char, cũng như _size của kiểu int. _size sẽ lưu trữ thông tin về độ dài của chuỗi và _string sẽ là một mảng ký tự được phân bổ động. Đây là định nghĩa lớp trông như thế nào:

#bao gồm Chuỗi lớp; istream& toán tử>>(istream&, String&);
ostream& toán tử<<(ostream&, const String&); class String {
công cộng:
// tập hợp các hàm tạo
// để khởi tạo tự động
// Chuỗi strl; // Sợi dây()
// Chuỗi str2("chữ"); // Chuỗi(const char*);
// Chuỗi str3(str2); // Chuỗi(const Chuỗi&); Sợi dây();
Chuỗi(const char*);
Chuỗi(const Chuỗi&); // hàm hủy
~Chuỗi(); // toán tử gán
// strl = str2
// str3 = "một chuỗi ký tự" String& operator=(const String&);
Chuỗi& toán tử=(const char*); // toán tử kiểm tra đẳng thức
// strl == str2;
// str3 == "một chuỗi ký tự"; toán tử bool==(const String&);
toán tử bool==(const char*); // nạp chồng toán tử truy cập theo chỉ mục
// strl[ 0 ] = str2[ 0 ]; char& toán tử(int); // truy cập vào các thành viên của lớp
kích thước int() ( return _size; )
char* c_str() ( return _string; ) riêng tư:
int_size;
char *_string;
}

Lớp String có ba hàm tạo. Như đã thảo luận trong Phần 2.3, cơ chế nạp chồng cho phép bạn xác định nhiều cách triển khai hàm có cùng tên, miễn là chúng đều khác nhau về số lượng và/hoặc loại tham số của chúng. Hàm tạo đầu tiên

Nó là hàm tạo mặc định vì nó không yêu cầu giá trị ban đầu rõ ràng. Khi chúng tôi viết:

Đối với str1, hàm tạo như vậy được gọi.
Hai hàm tạo còn lại đều có một tham số. Vâng, đối với

Chuỗi str2("chuỗi ký tự");

Hàm tạo được gọi

Chuỗi(const char*);

Chuỗi str3(str2);

Người xây dựng

Chuỗi(const Chuỗi&);

Kiểu của hàm tạo được gọi được xác định bởi kiểu đối số thực tế. Hàm tạo cuối cùng, String(const String&), được gọi là hàm tạo sao chép vì nó khởi tạo một đối tượng bằng một bản sao của một đối tượng khác.
Nếu bạn viết:

Chuỗi str4(1024);

Điều này sẽ gây ra lỗi biên dịch vì không có hàm tạo nào có tham số kiểu int.
Một khai báo toán tử quá tải có định dạng sau:

Toán tử return_type op(parameter_list);

Trong đó toán tử là một từ khóa và op là một trong các toán tử được xác định trước: +, =, ==, v.v. (Xem Chương 15 để biết định nghĩa chính xác về cú pháp.) Đây là khai báo của toán tử chỉ số được nạp chồng:

Toán tử Char&(int);

Toán tử này có một tham số duy nhất kiểu int và trả về một tham chiếu đến một char. Một toán tử bị quá tải có thể bị quá tải nếu danh sách tham số của các phiên bản riêng lẻ khác nhau. Đối với lớp String, chúng ta sẽ tạo hai toán tử gán và đẳng thức khác nhau.
Để gọi hàm thành viên, hãy sử dụng toán tử truy cập thành viên dấu chấm (.) hoặc mũi tên (->). Chúng ta hãy khai báo các đối tượng kiểu String:

Đối tượng chuỗi ("Danny");
Chuỗi *ptr = Chuỗi mới("Anna");
Mảng chuỗi;
Đây là giao diện của lệnh gọi size() trên các đối tượng này:
vectơ kích cỡ(3);

// truy cập thành viên cho đối tượng (.); // các đối tượng có kích thước 5 kích cỡ[ 0 ] = object.size(); // truy cập thành viên cho con trỏ (->)
// ptr có kích thước 4
kích thước [ 1 ] = ptr->size(); // truy cập thành viên (.)
// mảng có kích thước 0
kích thước [ 2 ] = array.size();

Nó trả về 5, 4 và 0 tương ứng.
Các toán tử nạp chồng được áp dụng cho một đối tượng giống như các toán tử thông thường:

Tên chuỗi("Yadie"); Tên chuỗi2("Yodie"); // toán tử bool==(const String&)
nếu (tên == tên2)
trở lại;
khác
// Chuỗi& toán tử=(const Chuỗi&)
tên = tên2;

Khai báo hàm thành viên phải nằm trong định nghĩa lớp và định nghĩa hàm có thể nằm trong hoặc bên ngoài định nghĩa lớp. (Cả hai hàm size() và c_str() đều được định nghĩa bên trong một lớp.) Nếu một hàm được định nghĩa bên ngoài một lớp, thì chúng ta phải chỉ định, ngoài những thứ khác, nó thuộc về lớp nào. Trong trường hợp này, định nghĩa của hàm được đặt trong tệp nguồn, chẳng hạn như String.C, và định nghĩa của chính lớp đó được đặt trong tệp tiêu đề (String.h trong ví dụ của chúng tôi), tệp này phải được đưa vào nguồn :

// nội dung của file nguồn: String.C // cho phép định nghĩa lớp String
#include "String.h" // bao gồm định nghĩa của hàm strcmp()
#bao gồm
bool // kiểu trả về
String:: // lớp chứa hàm đó
operator== // tên hàm: toán tử đẳng thức
(const String &rhs) // danh sách các tham số
{
nếu (_size != rhs._size)
trả về sai;
trả về strcmp(_strinq, rhs._string) ?
sai đúng;
}

Hãy nhớ lại rằng strcmp() là một hàm thư viện chuẩn C. Nó so sánh hai chuỗi có sẵn, trả về 0 nếu các chuỗi bằng nhau và khác 0 nếu chúng không bằng nhau. Toán tử điều kiện (?:) kiểm tra giá trị trước dấu chấm hỏi. Nếu đúng, giá trị của biểu thức ở bên trái dấu hai chấm sẽ được trả về; nếu không, giá trị ở bên phải sẽ được trả về. Trong ví dụ của chúng tôi, giá trị của biểu thức là sai nếu strcmp() trả về giá trị khác 0 và đúng nếu nó trả về giá trị 0. (Toán tử điều kiện được thảo luận trong phần 4.7.)
Thao tác so sánh được sử dụng khá thường xuyên, hàm thực hiện nó hóa ra lại nhỏ nên việc khai báo hàm này tích hợp sẵn (nội tuyến) sẽ rất hữu ích. Trình biên dịch thay thế văn bản của hàm thay vì gọi nó, do đó không lãng phí thời gian cho lệnh gọi như vậy. (Các hàm dựng sẵn sẽ được thảo luận trong Phần 7.6.) Một hàm thành viên được định nghĩa trong một lớp được cài sẵn theo mặc định. Nếu nó được định nghĩa bên ngoài lớp, để khai báo nó tích hợp, bạn cần sử dụng từ khóa inline:

Bool nội tuyến String::operator==(const String &rhs) ( // điều tương tự )

Định nghĩa của hàm dựng sẵn phải có trong tệp tiêu đề chứa định nghĩa lớp. Bằng cách xác định lại toán tử == làm toán tử nội tuyến, chúng ta phải di chuyển chính văn bản hàm từ tệp String.C sang tệp String.h.
Sau đây là cách thực hiện thao tác so sánh một đối tượng String với kiểu chuỗi có sẵn:

Chuỗi bool nội tuyến::operator==(const char *s) ( return strcmp(_string, s) ? false: true; )

Tên hàm tạo giống với tên lớp. Nó được coi là không trả về một giá trị, do đó không cần chỉ định giá trị trả về trong định nghĩa hoặc trong phần nội dung của nó. Có thể có một số nhà xây dựng. Giống như bất kỳ hàm nào khác, chúng có thể được khai báo nội tuyến.

#bao gồm // hàm tạo nội tuyến mặc định String::String()
{
_kích thước = 0;
_string = 0;
) Chuỗi nội tuyến::String(const char *str) ( if (! str) ( _size = 0; _string = 0; ) else ( _size = str1en(str); strcpy(_string, str); ) // sao chép hàm tạo
Chuỗi nội tuyến::String(const String &rhs)
{
kích thước = rhs._size;
nếu (! rhs._string)
_string = 0;
khác(
_string = char mới[ _size + 1 ];
} }

Vì chúng ta cấp phát bộ nhớ động bằng toán tử new nên chúng ta cần giải phóng nó bằng cách gọi delete khi không còn cần đối tượng String nữa. Một hàm thành viên đặc biệt khác phục vụ mục đích này - hàm hủy, được gọi tự động trên một đối tượng tại thời điểm đối tượng này không còn tồn tại. (Xem Chương 7 về vòng đời của đối tượng.) Tên của hàm hủy được hình thành từ ký tự dấu ngã (~) và tên của lớp. Đây là định nghĩa của hàm hủy lớp String. Đây là nơi chúng tôi gọi thao tác xóa để giải phóng bộ nhớ được phân bổ trong hàm tạo:

Chuỗi nội tuyến: :~String() ( delete _string; )

Cả hai toán tử gán quá tải đều sử dụng từ khóa đặc biệt this.
Khi chúng tôi viết:

Chuỗi namel("orville"), name2("wilbur");
name = "Orville Wright";
đây là một con trỏ đánh địa chỉ đối tượng name1 trong phần thân hàm của thao tác gán.
this luôn trỏ đến đối tượng lớp mà qua đó hàm được gọi. Nếu như
ptr->kích thước();
obj[ 1024 ];

Khi đó bên trong size() giá trị của this sẽ là địa chỉ được lưu trong ptr. Bên trong thao tác chỉ mục, phần này chứa địa chỉ của obj. Bằng cách hủy tham chiếu this (sử dụng *this), chúng ta sẽ có được chính đối tượng đó. (Con trỏ this được mô tả chi tiết ở Phần 13.4.)

Chuỗi nội tuyến& Chuỗi::operator=(const char *s) ( if (! s) ( _size = 0; delete _string; _string = 0; ) else ( _size = str1en(s); delete _string; _string = new char[ _size + 1 ]; strcpy(_string, s); trả về *this;

Khi thực hiện thao tác gán, một lỗi thường mắc phải là họ quên kiểm tra xem đối tượng đang được sao chép có phải là đối tượng mà bản sao đang được tạo vào hay không. Chúng tôi sẽ thực hiện kiểm tra này bằng cách sử dụng cùng một con trỏ this:

Inline String& String::operator=(const String &rhs) ( // trong biểu thức // namel = *pointer_to_string // cái này đại diện cho name1, // rhs - *pointer_to_string. if (this != &rhs) (

Đây là nguyên văn đầy đủ của thao tác gán một đối tượng cùng loại cho một đối tượng String:

Chuỗi nội tuyến& Chuỗi::operator=(const String &rhs) ( if (this != &rhs) ( delete _string; _size = rhs._size; if (! rhs._string)
_string = 0;
khác(
_string = char mới[ _size + 1 ];
strcpy(_string, rhs._string);
}
}
trả lại *cái này;
}

Thao tác lấy chỉ mục gần giống với thao tác thực hiện đối với mảng Array mà chúng ta đã tạo ở phần 2.3:

#bao gồm ký tự nội tuyến &
Chuỗi::toán tử (int elem)
{
khẳng định(elem >= 0 && elem< _size);
return _string[ elem ];
}

Các toán tử đầu vào và đầu ra được triển khai dưới dạng các hàm riêng biệt chứ không phải là thành viên lớp. (Chúng ta sẽ nói về lý do của điều này trong Phần 15.2. Phần 20.4 và 20.5 nói về việc nạp chồng các toán tử đầu vào và đầu ra của thư viện iostream.) Toán tử đầu vào của chúng ta có thể đọc tối đa 4095 ký tự. setw() là một trình thao tác được xác định trước, nó đọc một số ký tự nhất định trừ 1 từ luồng đầu vào, do đó đảm bảo rằng chúng ta không làm tràn bộ đệm nội bộ inBuf. (Chương 20 thảo luận chi tiết về trình thao tác setw().) Để sử dụng các trình thao tác, bạn phải bao gồm tệp tiêu đề tương ứng:

#bao gồm inline istream& operator>>(istream &io, String &s) ( // giới hạn nhân tạo: 4096 ký tự const int 1imit_string_size = 4096; char inBuf[ limit_string_size ]; // setw() được bao gồm trong thư viện iostream // nó giới hạn kích thước của khối có thể đọc được thành 1imit_string_size -l io >> setw(1imit_string_size) >> inBuf; s = mBuf; // String::operator=(const char*);

Toán tử đầu ra cần quyền truy cập vào biểu diễn bên trong của Chuỗi. Vì toán tử<< не является функцией-членом, он не имеет доступа к закрытому члену данных _string. Ситуацию можно разрешить двумя способами: объявить operator<< дружественным классу String, используя ключевое слово friend (дружественные отношения рассматриваются в разделе 15.2), или реализовать встраиваемую (inline) функцию для доступа к этому члену. В нашем случае уже есть такая функция: c_str() обеспечивает доступ к внутреннему представлению строки. Воспользуемся ею при реализации операции вывода:

Toán tử & luồng nội tuyến<<(ostream& os, const String &s) { return os << s.c_str(); }

Dưới đây là một chương trình ví dụ sử dụng lớp String. Chương trình này lấy các từ từ luồng đầu vào và đếm tổng số của chúng, cũng như số từ "the" và "it", đồng thời ghi lại các nguyên âm gặp phải.

#bao gồm #include "String.h" int main() ( int aCnt = 0, eCnt = 0, iCnt = 0, oCnt = 0, uCnt = 0, theCnt = 0, itCnt = 0, wdCnt = 0, notVowel = 0; / / Các từ “The” và “It”
// chúng ta sẽ kiểm tra bằng cách sử dụng operator==(const char*)
Chuỗi nhưng, the("the"), it("it"); // toán tử>>(ostream&, String&)
trong khi (cin >> buf) (
++wdCnt; // nhà điều hành<<(ostream&, const String&)
cout<< buf << " "; if (wdCnt % 12 == 0)
cout<< endl; // String::operator==(const String&) and
// String::operator==(const char*);
if (buf == the | | buf == "The")
++theCnt;
khác
if (buf == nó || buf == "Nó")
++nóCnt; // gọi String::s-ize()
vì (int ix =0; ix< buf.sizeO; ++ix)
{
// gọi String::operator(int)
switch(buf[ ix ])
{
trường hợp “a”: trường hợp “A”: ++aCnt; phá vỡ;
trường hợp “e”: trường hợp “E”: ++eCnt; phá vỡ;
trường hợp "i": trường hợp "I": ++iCnt; phá vỡ;
trường hợp "o": trường hợp "0": ++oCnt; phá vỡ;
trường hợp "u": trường hợp "U": ++uCnt; phá vỡ;
mặc định: ++notVowe1; phá vỡ;
}
}
) // nhà điều hành<<(ostream&, const String&)
cout<< "\n\n"
<< "Слов: " << wdCnt << "\n\n"
<< "the/The: " << theCnt << "\n"
<< "it/It: " << itCnt << "\n\n"
<< "согласных: " < << "a: " << aCnt << "\n"
<< "e: " << eCnt << "\n"
<< "i: " << ICnt << "\n"
<< "o: " << oCnt << "\n"
<< "u: " << uCnt << endl;
}

Hãy kiểm tra chương trình: chúng tôi sẽ cung cấp cho nó một đoạn trong câu chuyện thiếu nhi được viết bởi một trong những tác giả của cuốn sách này (chúng ta sẽ gặp câu chuyện này ở Chương 6). Đây là kết quả của chương trình:

Alice Emma có mái tóc dài màu đỏ bồng bềnh. Bố cô ấy nói khi gió thổi qua mái tóc của cô ấy, nó trông gần như sống động, giống như một con chim lửa đang bay. Anh nói với cô rằng một con chim lửa xinh đẹp, huyền diệu nhưng chưa được thuần hóa. “Bố ơi, im đi, không có chuyện đó đâu,” cô nói với ông, đồng thời muốn ông kể thêm cho cô nghe. Cô bé ngượng ngùng hỏi, "Ý con là bố có ở đó không?" Số từ: 65
cái/cái: 2
nó/Nó: 1
phụ âm: 190
một: 22
đ: 30
tôi: 24
ồ: 10
bạn: 7

Bài tập 3.26

Việc triển khai các hàm tạo và toán tử gán của chúng tôi chứa rất nhiều sự lặp lại. Hãy cân nhắc việc chuyển mã trùng lặp sang một hàm thành viên riêng biệt, như đã thực hiện trong Phần 2.3. Hãy chắc chắn rằng tùy chọn mới hoạt động.

Bài tập 3.27

Sửa đổi chương trình kiểm tra để nó cũng đếm các phụ âm b, d, f, s, t.

Bài tập 3.28

Viết hàm thành viên đếm số lần xuất hiện của một ký tự trong Chuỗi bằng cách sử dụng khai báo sau:

Chuỗi lớp ( public: // ... int count(char ch) const; // ... );

Bài tập 3.29

Triển khai toán tử nối chuỗi (+) để nó nối hai chuỗi và trả về kết quả trong một đối tượng Chuỗi mới. Đây là khai báo hàm:

Chuỗi lớp ( public: // ... String operator+(const String &rhs) const; // ... );

Trong ngôn ngữ C, có sự phân biệt giữa khái niệm “kiểu dữ liệu” và “công cụ sửa đổi kiểu”. Kiểu dữ liệu là số nguyên và bộ sửa đổi được ký hoặc không dấu. Số nguyên có dấu sẽ có cả giá trị dương và âm, trong khi số nguyên không dấu sẽ chỉ có giá trị dương. Có năm loại cơ bản trong ngôn ngữ C.

• char – ký tự.

Một biến kiểu char có kích thước 1 byte, giá trị của nó là các ký tự khác nhau từ bảng mã, ví dụ: 'f', ':', 'j' (khi viết trong chương trình, chúng được đặt trong một biến duy nhất). trích dẫn).

• int - toàn bộ.

Kích thước của biến kiểu int không được xác định trong tiêu chuẩn ngôn ngữ C. Trong hầu hết các hệ thống lập trình, kích thước của biến int tương ứng với kích thước của toàn bộ từ máy. Ví dụ: trong trình biên dịch dành cho bộ xử lý 16 bit, một biến kiểu int có kích thước 2 byte. Trong trường hợp này, các giá trị có dấu của biến này có thể nằm trong khoảng từ -32768 đến 32767.

• nổi - thực.

Từ khóa float cho phép bạn xác định các biến có kiểu thực. Các giá trị của chúng có phần phân số cách nhau bằng dấu chấm, ví dụ: -5,6, 31,28, v.v. Số thực cũng có thể được viết dưới dạng dấu phẩy động, ví dụ: -1,09e+4. Số trước ký hiệu “e” được gọi là số mũ, và số sau “e” được gọi là số mũ. Một biến kiểu float chiếm 32 bit trong bộ nhớ. Nó có thể nhận các giá trị trong khoảng từ 3,4e-38 đến 3,4e+38.

• double – độ chính xác gấp đôi thực tế;

Từ khóa double cho phép bạn xác định một biến thực có độ chính xác kép. Nó chiếm dung lượng bộ nhớ gấp đôi so với biến float. Một biến kiểu double có thể nhận các giá trị trong khoảng từ 1.7e-308 đến 1.7e+308.

• khoảng trống - không có giá trị.

Từ khóa void được sử dụng để vô hiệu hóa giá trị của một đối tượng, ví dụ như để khai báo một hàm không trả về bất kỳ giá trị nào.

Các loại biến:

Các chương trình hoạt động với nhiều dữ liệu khác nhau, có thể đơn giản hoặc có cấu trúc. Dữ liệu đơn giản là số nguyên và số thực, ký hiệu và con trỏ (địa chỉ của các đối tượng trong bộ nhớ). Số nguyên không có phần phân số nhưng số thực thì có. Dữ liệu có cấu trúc là mảng và cấu trúc; chúng sẽ được thảo luận dưới đây.

Biến là một ô trong bộ nhớ máy tính có tên và lưu trữ một số giá trị. Giá trị của biến có thể thay đổi trong quá trình thực hiện chương trình. Khi một giá trị mới được ghi vào một ô, giá trị cũ sẽ bị xóa.

Đó là phong cách tốt để đặt tên biến có ý nghĩa. Tên biến có thể chứa từ một đến 32 ký tự. Được phép sử dụng chữ thường và chữ in hoa, số và dấu gạch dưới, được coi là một chữ cái trong C. Ký tự đầu tiên phải là một chữ cái. Tên biến không thể khớp với các từ dành riêng.

Nhập ký tự

char là loại tiết kiệm nhất. Kiểu char có thể được ký hoặc không dấu. Được ký hiệu là “char ký tự có dấu” (loại có dấu) và “char không dấu” (loại không dấu). Kiểu đã ký có thể lưu trữ các giá trị trong phạm vi -128 đến +127. Chưa ký - từ 0 đến 255. 1 byte bộ nhớ (8 bit) được phân bổ cho biến char.

Các từ khóa có dấu và không dấu cho biết cách diễn giải bit 0 của biến được khai báo, tức là nếu từ khóa không dấu được chỉ định, thì bit 0 được hiểu là một phần của số, nếu không thì bit 0 được hiểu là có dấu.

Kiểu int

Giá trị nguyên int có thể ngắn hoặc dài. Từ khóa ngắn được đặt sau từ khóa đã ký hoặc chưa ký. Vì vậy có các loại: int ngắn có dấu, int ngắn không dấu, int dài có dấu, int dài không dấu.

Một biến thuộc loại signature short int (số nguyên ngắn có dấu) có thể lấy các giá trị từ -32768 đến +32767, unsigned short int (số nguyên ngắn không dấu) - từ 0 đến 65535. Mỗi biến trong số chúng được phân bổ chính xác hai byte bộ nhớ (16 chút ít).

Khi khai báo một biến kiểu signature short int, từ khóa signature và short có thể bị bỏ qua, và kiểu biến đó có thể được khai báo đơn giản là int. Cũng có thể khai báo loại này bằng một từ khóa ngắn gọn.

Biến int unsigned short có thể được khai báo là unsigned int hoặc unsigned short.

Đối với mỗi giá trị int long int hoặc unsigned long int, 4 byte bộ nhớ (32 bit) được phân bổ. Giá trị của các biến thuộc loại này có thể nằm trong khoảng từ -2147483648 đến 2147483647 và từ 0 đến 4294967295 tương ứng.

Ngoài ra còn có các biến kiểu int dài dài, trong đó 8 byte bộ nhớ được phân bổ (64 bit). Chúng có thể được ký hoặc không được ký. Đối với loại đã ký, phạm vi giá trị là từ -9223372036854775808 đến 9223372036854775807, đối với loại không dấu - từ 0 đến 18446744073709551615. Loại đã ký cũng có thể được khai báo đơn giản bằng hai từ khóa dài và dài.

Khai báo biến

Các biến được khai báo trong câu lệnh khai báo. Câu lệnh khai báo bao gồm đặc tả kiểu và danh sách tên biến được phân tách bằng dấu phẩy. Phải có dấu chấm phẩy ở cuối.

[sửa đổi] mã định danh type_specifier [, mã định danh] ...

Công cụ sửa đổi – từ khóa đã ký, không dấu, ngắn, dài.
Công cụ xác định loại là từ khóa char hoặc int chỉ định loại biến được khai báo.
Mã định danh là tên của biến.

Char x; int a, b, c; không dấu dài dài y;

Khi được khai báo, một biến có thể được khởi tạo, nghĩa là được gán một giá trị ban đầu.

Int x = 100;

Khi khai báo, biến x sẽ chứa ngay số 100. Tốt nhất nên khai báo các biến khởi tạo trên các dòng riêng biệt.

Lập trình viên nói:

Xin chào! Tôi đã đọc bài viết của bạn. Tôi đã rất buồn và buồn cười cùng một lúc. Cụm từ này của bạn đặc biệt hấp dẫn: "Vì một biến kiểu char thường được sử dụng như một mảng nên số lượng giá trị có thể có sẽ được xác định." 😆 😆 😆
Tôi không cười nhạo bạn. Tạo một trang web thực sự là một kỳ công. Tôi chỉ muốn hỗ trợ bạn lời khuyên và chỉ ra một số sai sót.

1. Giá trị của biến kiểu char được gán như sau:

Đây:

Char a = *"A";

Con trỏ tới mảng bị hủy địa chỉ và kết quả là giá trị của phần tử đầu tiên của mảng được trả về, tức là. 'MỘT'

2. Việc reset xảy ra như sau:

Char a = NULL;
ký tự b = ();

// Và đây là cách xóa dòng trong phần thân chương trình

"" - ký hiệu này được gọi là dấu kết thúc số 0. Nó được đặt ở cuối dòng. Chính bạn mà không hề biết đã điền vào mảng s1 trong bài viết của mình bằng ký hiệu này. Nhưng chỉ có thể gán ký hiệu này cho phần tử 0 của mảng.

3. Hãy thoải mái sử dụng thuật ngữ.
Dấu = là phép gán.
Dấu * là thao tác khử địa chỉ.
Ý tôi là đoạn này của bài viết: “Mọi thứ hóa ra đơn giản đến vậy, trước dấu = bạn phải đặt dấu * và bạn phải khai báo số phần tử (số 0 tương ứng với số đầu tiên)”

Đừng hiểu sai ý tôi, bài viết không thể tồn tại ở dạng hiện tại. Đừng lười biếng, hãy viết lại nó.
Bạn có một trách nhiệm lớn lao! Tôi nghiêm túc đấy. Các trang trên trang web của bạn được đưa vào trang đầu tiên của kết quả Yandex. Nhiều người đã bắt đầu lặp lại sai lầm của bạn.

Chúc may mắn! Bạn có thể làm được!

:
Tôi biết điều này từ lâu rồi, chỉ là đọc đi đọc lại 200 bài liên tục để sửa cái gì đó cũng khó. Và một số kiểu thô lỗ viết theo cách mà ngay cả khi biết điều gì là tốt nhất để sửa, họ cũng không có ý định sửa nó.

Tôi sẽ vui lòng sửa các lỗi khác. sửa bất kỳ điểm không chính xác nào nếu chúng xuất hiện. Tôi đánh giá cao sự giúp đỡ của bạn. cảm ơn bạn. Tôi đã biết điều này từ lâu, thật khó để đọc lại 200 bài viết liên tục để sửa một cái gì đó. Và một số kiểu thô lỗ viết theo cách mà ngay cả khi biết điều gì là tốt nhất để sửa, họ cũng không có ý định sửa nó.
Với char b = (); Đây không phải là số 0 chút nào. Ít nhất tôi sẽ kiểm tra nó.
nếu chúng ta nói về ký tự null "" ; Tôi biết rõ khi tôi lấp đầy đường kẻ đó rằng mục tiêu là thể hiện sự làm sạch thực sự chứ không phải thứ gì đó có thể nhìn thấy bằng mắt, bởi vì đường kẻ này bao gồm rác, đôi khi gây cản trở. Bạn nên cẩn thận hơn với các thuật ngữ, "ký hiệu kết thúc null" hoặc chỉ "ký hiệu null", không phải dấu kết thúc))) Và biểu tượng kết thúc nghe có vẻ hay.

Tôi sẽ hiện đại hóa bài viết, nhưng tôi sẽ không chuyển sang phong cách của người khác. Nếu tôi nghĩ rằng người mới bắt đầu hiểu nó theo cách này dễ dàng hơn là theo cách họ muốn, thì tôi sẽ để nó như vậy. Bạn cũng đừng hiểu lầm tôi. Đối với người mới bắt đầu yếu, từ “dấu hiệu” dễ hiểu và dễ nhớ hơn nhiều so với định nghĩa và tên của từng dấu hiệu. Không có sai lầm nào cả, đó là một dấu hiệu - một dấu hiệu. Ít nhấn mạnh hơn vào cái này sẽ nhấn mạnh hơn vào cái kia.

Tôi sẽ vui lòng sửa các lỗi khác. sửa bất kỳ điểm không chính xác nào nếu chúng xuất hiện. Tôi đánh giá cao sự giúp đỡ của bạn. Cảm ơn.

Xin chào lần nữa!
Tôi muốn làm rõ. Thuật ngữ “zero-terminator” (terminator trong tiếng Anh limiter) được giáo viên của tôi ở trường đại học sử dụng. Rõ ràng đây là trường học cũ!
Đối với việc đặt lại hàng.
ký tự b = (); Đây thực sự là một sự thiết lập lại. Toàn bộ mảng chứa đầy số không. Nếu bạn không tin tôi, hãy kiểm tra nó!
Nếu chúng ta xem xét một dòng theo nghĩa tự nhiên, hàng ngày của nó, thì một dòng “trống” sẽ là một dòng không có một ký tự nào. Do đó, trong 99,9% trường hợp, việc đặt ký tự null ở đầu là đủ. Thông thường, một chuỗi được xử lý tối đa ký tự null đầu tiên và những ký tự nào theo sau chuỗi đó không còn quan trọng nữa. Tôi hiểu rằng bạn muốn đặt lại dòng. Tôi vừa quyết định đưa ra một lựa chọn cổ điển đã được thử nghiệm theo thời gian.

:
Khi “Thông thường quá trình xử lý chuỗi tiến tới ký tự rỗng đầu tiên và những ký tự nào theo sau nó không còn quan trọng nữa” - vâng, chuỗi bị rỗng
Nếu chúng ta xem xét "số 0 thực sự của tất cả các ô trong một hàng (mà tôi đã viết)" - không, không phải số 0 và ngay cả ký tự đầu tiên cũng không bằng 0. Tôi đã kiểm tra tùy chọn này. MinGW(CodeBlock) - toàn bộ mảng cung cấp ký tự "a"
Tôi không nghĩ đây là lý do để tranh luận.