Bạn đang xem : cách viết một hàm trong c ++

Functions

Trong C ++, một hàm là một nhóm các câu lệnh được đặt tên và có thể được gọi từ một số điểm của chương trình. Cú pháp phổ biến nhất để xác định một hàm là:


tên kiểu (tham số1, tham số2, …) {câu lệnh}


Ở đâu:
type là loại giá trị được trả về bởi hàm.
name là mã định danh mà hàm có thể được gọi.
tham số (bao nhiêu tùy ý): Mỗi tham số bao gồm một kiểu theo sau là một số nhận dạng, với mỗi tham số được phân tách với tham số tiếp theo bằng dấu phẩy. Mỗi tham số trông rất giống một khai báo biến thông thường (ví dụ: int x ) và trên thực tế hoạt động bên trong hàm như một biến thông thường là cục bộ của hàm. Mục đích của các tham số là cho phép truyền các đối số tới hàm từ vị trí mà nó được gọi từ đó.
– Các câu lệnh là phần thân của hàm. Nó là một khối câu lệnh được bao quanh bởi dấu ngoặc nhọn {} chỉ định chức năng thực sự hoạt động.

Hãy xem một ví dụ:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  // ví dụ về hàm
#include & lt; iostream & gt;
sử dụng không gian tên std;

int cộng (int a, int b)
{
  int r;
  r = a + b;
  trả lại r;
}

int main ()
{
  int z;
  z = phép cộng (5,3);
  cout & lt; & lt; "Kết quả là" & lt; & lt; z;
}  
 Kết quả là 8 

Chương trình này được chia thành hai chức năng: bổ sung chính . Hãy nhớ rằng bất kể thứ tự mà chúng được xác định, chương trình C ++ luôn bắt đầu bằng cách gọi main . Trên thực tế, main là hàm duy nhất được gọi tự động và mã trong bất kỳ hàm nào khác chỉ được thực thi nếu hàm của nó được gọi từ main (trực tiếp hoặc gián tiếp).


Trong ví dụ trên, main bắt đầu bằng cách khai báo biến z kiểu int và ngay sau đó, nó thực hiện lệnh gọi hàm đầu tiên: it cuộc gọi bổ sung . Lời gọi hàm tuân theo một cấu trúc rất giống với phần khai báo của nó. Trong ví dụ trên, lệnh gọi add có thể được so sánh với định nghĩa của nó chỉ vài dòng trước đó:

Các tham số trong khai báo hàm có sự tương ứng rõ ràng với các đối số được truyền trong lời gọi hàm. Lệnh gọi chuyển hai giá trị, 5 3 , cho hàm; chúng tương ứng với các tham số a b , được khai báo cho hàm add .

Tại thời điểm mà hàm được gọi từ bên trong hàm main, điều khiển được chuyển cho hàm add : tại đây, việc thực thi main sẽ bị dừng và sẽ chỉ tiếp tục sau khi < mã> bổ sung chức năng kết thúc. Tại thời điểm gọi hàm, giá trị của cả hai đối số ( 5 3 ) được sao chép vào các biến cục bộ int a int b trong hàm.

Sau đó, bên trong add , một biến cục bộ khác được khai báo ( int r ) và bằng biểu thức r = a + b , kết quả of a plus b được gán cho r ; mà, đối với trường hợp này, trong đó a là 5 và b là 3, có nghĩa là 8 được gán cho r .

Câu lệnh cuối cùng trong hàm:

   
  return r;  

Kết thúc hàm add và trả điều khiển trở lại điểm mà hàm được gọi; trong trường hợp này: thành chức năng main . Tại thời điểm chính xác này, chương trình tiếp tục lại khóa học của nó trên main trở lại chính xác tại thời điểm mà nó bị gián đoạn bởi lệnh gọi đến add . Nhưng ngoài ra, vì add có kiểu trả về, lệnh gọi được đánh giá là có giá trị và giá trị này là giá trị được chỉ định trong câu lệnh trả về đã kết thúc add : in this trường hợp cụ thể, giá trị của biến cục bộ r , tại thời điểm câu lệnh return có giá trị là 8.

Do đó, lệnh gọi đến add là một biểu thức có giá trị được trả về bởi hàm và trong trường hợp này, giá trị đó, 8, được gán cho z . Nó giống như thể toàn bộ lệnh gọi hàm ( add (5,3) ) được thay thế bằng giá trị mà nó trả về (tức là, 8).

Sau đó, main chỉ cần in giá trị này bằng cách gọi:

   
  cout & lt; & lt; "Kết quả là" & lt; & lt; z;  

Một hàm thực sự có thể được gọi nhiều lần trong một chương trình và đối số của nó đương nhiên không chỉ giới hạn ở các ký tự:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
  // ví dụ về hàm
#include & lt; iostream & gt;
sử dụng không gian tên std;

phép trừ int (int a, int b)
{
  int r;
  r = a-b;
  trả lại r;
}

int main ()
{
  int x = 5, y = 3, z;
  z = phép trừ (7,2);
  cout & lt; & lt; "Kết quả đầu tiên là" & lt; & lt; z & lt; & lt; '\N';
  cout & lt; & lt; "Kết quả thứ hai là" & lt; & lt; phép trừ (7,2) & lt; & lt; '\N';
  cout & lt; & lt; "Kết quả thứ ba là" & lt; & lt; phép trừ (x, y) & lt; & lt; '\N';
  z = 4 + phép trừ (x, y);
  cout & lt; & lt; "Kết quả thứ tư là" & lt; & lt; z & lt; & lt; '\N';
}  
 Kết quả đầu tiên là 5
Kết quả thứ hai là 5
Kết quả thứ ba là 2
Kết quả thứ tư là 6 

Tương tự như hàm add trong ví dụ trước, ví dụ này định nghĩa một hàm subtract , hàm này chỉ trả về sự khác biệt giữa hai tham số của nó. Lần này, main gọi hàm này nhiều lần, thể hiện nhiều cách khả thi hơn trong đó một hàm có thể được gọi.

Hãy kiểm tra từng lệnh gọi này, lưu ý rằng bản thân mỗi lệnh gọi hàm là một biểu thức được đánh giá là giá trị mà nó trả về. Một lần nữa, bạn có thể nghĩ về nó như thể chính lệnh gọi hàm đã được thay thế bằng giá trị trả về:

  1 
2
  z = subtraction (7,2);
cout & lt; & lt; "Kết quả đầu tiên là" & lt; & lt; z;  

Nếu chúng ta thay thế lời gọi hàm bằng giá trị mà nó trả về (tức là 5), chúng ta sẽ có:

  1 
2
  z = 5;
cout & lt; & lt; "Kết quả đầu tiên là" & lt; & lt; z;  

Với quy trình tương tự, chúng tôi có thể diễn giải:

   
  cout & lt; & lt; "Kết quả thứ hai là" & lt; & lt; phép trừ (7,2);  

như:

   
  cout & lt; & lt; "Kết quả thứ hai là" & lt; & lt; 5;  

vì 5 là giá trị được trả về bởi subtraction (7,2) .

Trong trường hợp:

   
  cout & lt; & lt; "Kết quả thứ ba là" & lt; & lt; phép trừ (x, y);  

Các đối số được truyền cho phép trừ là các biến thay vì các ký tự. Điều đó cũng hợp lệ, và hoạt động tốt. Hàm được gọi với các giá trị x y có tại thời điểm gọi tương ứng: 5 và 3, trả về 2 kết quả.

Cuộc gọi thứ tư một lần nữa tương tự:

   
  z = 4 + subtraction (x, y);  

Sự bổ sung duy nhất là bây giờ lời gọi hàm cũng là một toán hạng của một phép toán cộng. Một lần nữa, kết quả giống như nếu lệnh gọi hàm được thay thế bằng kết quả của nó: 6. Lưu ý rằng nhờ tính chất giao hoán của phép cộng, phần trên cũng có thể được viết thành:

   
  z = subtraction (x, y) + 4;  

Với kết quả chính xác như nhau. Cũng lưu ý rằng dấu chấm phẩy không nhất thiết phải đi sau lệnh gọi hàm, nhưng, như mọi khi, ở cuối toàn bộ câu lệnh. Một lần nữa, bạn có thể dễ dàng nhìn thấy lại logic đằng sau bằng cách thay thế các lệnh gọi hàm bằng giá trị trả về của chúng:

  1 
2
  z = 4 + 2; // tương tự như z = 4 + subtraction (x, y);
z = 2 + 4; // tương tự như z = subtraction (x, y) + 4;  

Các hàm cho phép cấu trúc chương trình theo các đoạn mã để thực hiện các tác vụ riêng lẻ. Trong C ++, một hàm là một nhóm các câu lệnh được đặt tên và có thể được gọi từ một số điểm của chương trình. Cú pháp phổ biến nhất để xác định một hàm là: Trong đó: là kiểu của giá trị được trả về bởi hàm. Là định danh mà hàm có thể được gọi. định danh, với mỗi tham số được phân tách với tham số tiếp theo bằng dấu phẩy. Mỗi tham số trông rất giống một khai báo biến thông thường (ví dụ:), và trên thực tế hoạt động bên trong hàm như một biến thông thường là cục bộ của hàm. Mục đích của các tham số là cho phép truyền các đối số cho hàm từ vị trí mà nó được gọi là from. Là phần thân của hàm. Nó là một khối câu lệnh được bao quanh bởi dấu ngoặc nhọn {} chỉ định chức năng thực sự hoạt động. Chúng ta hãy xem một ví dụ: Chương trình này được chia thành hai hàm: và. Hãy nhớ rằng bất kể thứ tự mà chúng được xác định, một chương trình C ++ luôn bắt đầu bằng cách gọi. Trên thực tế, là hàm duy nhất được gọi tự động và mã trong bất kỳ hàm nào khác chỉ được thực thi nếu hàm của nó được gọi từ (trực tiếp hoặc gián tiếp). thực hiện lệnh gọi hàm đầu tiên: nó gọi. Lời gọi hàm tuân theo một cấu trúc rất giống với phần khai báo của nó. Trong ví dụ trên, lệnh gọi có thể được so sánh với định nghĩa của nó chỉ vài dòng trước đó: Các tham số trong khai báo hàm có sự tương ứng rõ ràng với các đối số được truyền trong lệnh gọi hàm. Lời gọi chuyển hai giá trị và, đến hàm; chúng tương ứng với các tham số và, được khai báo cho hàm Tại thời điểm mà hàm được gọi từ bên trong hàm chính, điều khiển được chuyển cho hàm: tại đây, việc thực thi hàm sẽ dừng lại và sẽ chỉ tiếp tục sau khi hàm kết thúc. Tại thời điểm gọi hàm, giá trị của cả hai đối số (và) được sao chép vào các biến cục bộ và trong hàm. mà, đối với trường hợp này, trong đó 5 và 3, có nghĩa là 8 được gán cho Câu lệnh cuối cùng trong hàm: Kết thúc hàm và trả lại điều khiển trở lại điểm mà hàm được gọi; trong trường hợp này: để hoạt động. Vào thời điểm chính xác này, chương trình sẽ tiếp tục quá trình của nó trở lại chính xác tại thời điểm mà nó bị gián đoạn bởi cuộc gọi đến. Nhưng ngoài ra, vì có kiểu trả về, lệnh gọi được đánh giá là có giá trị và giá trị này là giá trị được chỉ định trong câu lệnh trả về đã kết thúc: trong trường hợp cụ thể này, giá trị của biến cục bộ, tại thời điểm câu lệnh có giá trị 8 Do đó, lệnh gọi là một biểu thức với giá trị được trả về bởi hàm và trong trường hợp này, giá trị đó, 8, được gán cho. Nó giống như thể toàn bộ lời gọi hàm () được thay thế bằng giá trị mà nó trả về (tức là 8). Sau đó, hàm main chỉ cần in ra giá trị này bằng cách gọi: Một hàm thực sự có thể được gọi nhiều lần trong một chương trình và đối số của nó đương nhiên không chỉ giới hạn ở các chữ: Tương tự như hàm trong ví dụ trước, ví dụ này định nghĩa một hàm, chỉ đơn giản là trả về sự khác biệt giữa hai tham số của nó. Lần này, gọi hàm này nhiều lần, thể hiện nhiều cách khả thi hơn trong đó một hàm có thể được gọi. Một lần nữa, bạn có thể nghĩ về nó như thể chính lệnh gọi hàm được thay thế bằng giá trị trả về: Nếu chúng ta thay thế lệnh gọi hàm bằng giá trị mà nó trả về (tức là, 5), chúng ta sẽ có: Với cùng một thủ tục, chúng ta có thể diễn giải: as: vì 5 là giá trị được trả về bởi Trong trường hợp: Các đối số được truyền cho phép trừ là các biến thay vì các ký tự. Điều đó cũng hợp lệ, và hoạt động tốt. Hàm được gọi với các giá trị và được chia sẻ tại thời điểm gọi lần lượt là: 5 và 3, trả về kết quả là 2. Lời gọi thứ tư một lần nữa tương tự: Điều bổ sung duy nhất là bây giờ lời gọi hàm cũng là một toán hạng của một phép cộng. Một lần nữa, kết quả cũng giống như nếu lệnh gọi hàm được thay thế bằng kết quả của nó: 6. Lưu ý rằng nhờ tính chất giao hoán của phép cộng, phần trên cũng có thể được viết thành: Với chính xác cùng một kết quả. Cũng lưu ý rằng dấu chấm phẩy không nhất thiết phải đi sau lệnh gọi hàm, nhưng, như mọi khi, ở cuối toàn bộ câu lệnh. Một lần nữa, bạn có thể dễ dàng nhìn thấy lại logic đằng sau bằng cách thay thế các lệnh gọi hàm bằng giá trị trả về của chúng:

Các hàm không có kiểu. Việc sử dụng khoảng trống

Cú pháp hiển thị ở trên cho các hàm:


tên kiểu (đối số1, đối số2 …) {câu lệnh}

Yêu cầu khai báo bắt đầu bằng một loại. Đây là kiểu giá trị được trả về bởi hàm. Nhưng nếu hàm không cần trả về giá trị thì sao? Trong trường hợp này, kiểu được sử dụng là void , là kiểu đặc biệt để thể hiện sự vắng mặt của giá trị. Ví dụ: một hàm chỉ in một tin nhắn có thể không cần trả về bất kỳ giá trị nào:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
  // ví dụ về hàm void
#include & lt; iostream & gt;
sử dụng không gian tên std;

void printmessage ()
{
  cout & lt; & lt; "Tôi là một hàm!";
}

int main ()
{
  printmessage ();
}  
 Tôi là một chức năng! 

void cũng có thể được sử dụng trong danh sách tham số của hàm để chỉ định rõ ràng rằng hàm không nhận tham số thực khi được gọi. Ví dụ: printmessage có thể được khai báo là:

  1 
2
3
4
  void printmessage (void)
{
  cout & lt; & lt; "Tôi là một hàm!";
}  

Trong C ++, một danh sách tham số trống có thể được sử dụng thay vì void với cùng ý nghĩa, nhưng việc sử dụng void trong danh sách đối số đã được ngôn ngữ C phổ biến, đây là một yêu cầu.

Một cái gì đó mà trong mọi trường hợp không phải là tùy chọn là các dấu ngoặc đơn theo sau tên hàm, không phải trong khai báo của nó cũng như khi gọi nó. Và ngay cả khi hàm không có tham số, ít nhất một cặp dấu ngoặc đơn trống sẽ luôn được thêm vào tên hàm. Xem cách gọi printmessage trong ví dụ trước:

   
  printmessage ();  

Dấu ngoặc đơn là những gì phân biệt các hàm với các loại khai báo hoặc câu lệnh khác. Phần sau sẽ không gọi hàm:

   
  printmessage;  

Cú pháp hiển thị ở trên cho các hàm: Yêu cầu khai báo bắt đầu bằng một loại. Đây là kiểu giá trị được trả về bởi hàm. Nhưng nếu hàm không cần trả về giá trị thì sao? Trong trường hợp này, kiểu được sử dụng là kiểu đặc biệt để thể hiện sự vắng mặt của giá trị. Ví dụ, một hàm chỉ in một thông báo có thể không cần trả về bất kỳ giá trị nào: cũng có thể được sử dụng trong danh sách tham số của hàm để chỉ định rõ ràng rằng hàm không nhận tham số thực khi được gọi. Ví dụ, có thể đã được khai báo là: Trong C ++, một danh sách tham số trống có thể được sử dụng thay vì có cùng ý nghĩa, nhưng việc sử dụng danh sách đối số này đã được ngôn ngữ C phổ biến, trong đó đây là một yêu cầu. tùy chọn là các dấu ngoặc đơn theo sau tên hàm, không có trong phần khai báo cũng như khi gọi nó. Và ngay cả khi hàm không có tham số, ít nhất một cặp dấu ngoặc đơn trống sẽ luôn được thêm vào tên hàm. Xem cách được gọi trong ví dụ trước: Dấu ngoặc đơn là thứ phân biệt các hàm với các loại khai báo hoặc câu lệnh khác. Phần sau sẽ không gọi hàm:

Giá trị trả về của main

Bạn có thể nhận thấy rằng kiểu trả về của main int , nhưng hầu hết các ví dụ trong chương này và các chương trước đó không thực sự trả về bất kỳ giá trị nào từ main .

Chà, có một vấn đề: Nếu quá trình thực thi main kết thúc bình thường mà không gặp phải câu lệnh return , trình biên dịch sẽ giả sử hàm kết thúc bằng một câu lệnh trả về ngầm định:

   
  trả về 0;  

Lưu ý rằng điều này chỉ áp dụng cho hàm main vì lý do lịch sử. Tất cả các hàm khác có kiểu trả về sẽ kết thúc bằng câu lệnh return thích hợp bao gồm giá trị trả về, ngay cả khi điều này không bao giờ được sử dụng.

Khi main trả về giá trị 0 (ngầm định hoặc rõ ràng), nó được môi trường hiểu là chương trình đã kết thúc thành công. Các giá trị khác có thể được trả về bởi main và một số môi trường cung cấp quyền truy cập vào giá trị đó cho người gọi theo một cách nào đó, mặc dù hành vi này không bắt buộc cũng như không nhất thiết phải di động giữa các nền tảng. Các giá trị cho main được đảm bảo sẽ được diễn giải theo cách giống nhau trên tất cả các nền tảng là:

giá trị
0 Chương trình đã thành công
EXIT_SUCCESS Chương trình đã thành công (tương tự như trên).
Giá trị này được xác định trong tiêu đề & lt; cstdlib & gt; .
EXIT_FAILURE Chương trình không thành công.
Giá trị này được xác định trong tiêu đề & lt; cstdlib & gt; .

Vì câu lệnh return 0; ngầm định cho main là một ngoại lệ phức tạp, một số tác giả coi việc viết câu lệnh một cách rõ ràng là một phương pháp hay.

Bạn có thể nhận thấy rằng kiểu trả về làis, nhưng hầu hết các ví dụ trong chương này và các chương trước đó không thực sự trả về bất kỳ giá trị nào từWell, có một vấn đề: Nếu việc thực thi kết thúc bình thường mà không gặp phải kinh ngạc, trình biên dịch sẽ giả sử hàm kết thúc bằng một câu lệnh trả về ngầm định: Lưu ý rằng điều này chỉ áp dụng cho hàm vì lý do lịch sử. Tất cả các hàm khác có kiểu trả về sẽ kết thúc bằng một mệnh đề bao gồm giá trị trả về, ngay cả khi giá trị này không bao giờ được sử dụng. Các giá trị khác có thể được trả về và một số môi trường cung cấp quyền truy cập vào giá trị đó cho người gọi theo một cách nào đó, mặc dù hành vi này không bắt buộc cũng như không nhất thiết phải di động giữa các nền tảng. Các giá trị được đảm bảo sẽ được diễn giải theo cách giống nhau trên tất cả các nền tảng là: Bởi vì câu lệnh ngầm tạo ra một ngoại lệ phức tạp, một số tác giả coi việc viết câu lệnh một cách rõ ràng là một phương pháp hay.

Các đối số được chuyển theo giá trị và bằng tham chiếu

Trong các hàm đã thấy trước đó, các đối số luôn được truyền. Điều này có nghĩa là, khi gọi một hàm, những gì được truyền cho hàm là các giá trị của các đối số này tại thời điểm gọi, được sao chép vào các biến được đại diện bởi các tham số hàm. Ví dụ: lấy:

  1 
2
  int x = 5, y = 3, z;
z = add (x, y);  

Trong trường hợp này, phép cộng hàm được chuyển 5 và 3, là bản sao của các giá trị x y , tương ứng. Các giá trị này (5 và 3) được sử dụng để khởi tạo các biến được đặt làm tham số trong định nghĩa của hàm, nhưng bất kỳ sửa đổi nào của các biến này trong hàm đều không ảnh hưởng đến giá trị của các biến x và y bên ngoài nó, bởi vì x và y là bản thân chúng không được chuyển tới hàm trong lệnh gọi mà chỉ là bản sao của các giá trị của chúng tại thời điểm đó.

Tuy nhiên, trong một số trường hợp nhất định, có thể hữu ích khi truy cập một biến bên ngoài từ bên trong một hàm. Để làm điều đó, các đối số có thể được chuyển, thay vì. Ví dụ: hàm lặp lại trong mã này sao chép giá trị của ba đối số của nó, khiến các biến được sử dụng làm đối số thực sự được sửa đổi bởi lệnh gọi:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  // truyền tham số bằng tham chiếu
#include & lt; iostream & gt;
sử dụng không gian tên std;

void trùng lặp (int & amp; a, int & amp; b, int & amp; c)
{
  a * = 2;
  b * = 2;
  c * = 2;
}

int main ()
{
  int x = 1, y = 3, z = 7;
  nhân đôi (x, y, z);
  cout & lt; & lt; "x =" & lt; & lt; x & lt; & lt; ", y =" & lt; & lt; y & lt; & lt; ", z =" & lt; & lt; z;
  trả về 0;
}  
 x = 2, y = 6, z = 14 

Để có được quyền truy cập vào các đối số của nó, hàm khai báo các tham số của nó là. Trong C ++, các tham chiếu được biểu thị bằng dấu và ( & amp; ) theo sau loại tham số, như trong các tham số được lấy bởi trùng lặp trong ví dụ trên.

Khi một biến được truyền, những gì được truyền không còn là bản sao nữa, mà bản thân biến đó, biến được xác định bởi tham số hàm, bằng cách nào đó được liên kết với đối số được truyền vào hàm và bất kỳ sửa đổi nào trên các biến cục bộ tương ứng của chúng trong hàm được phản ánh trong các biến được truyền dưới dạng đối số trong lệnh gọi.

Trên thực tế, a , b c trở thành bí danh của các đối số được truyền trong lệnh gọi hàm ( x , y , và z ) và bất kỳ thay đổi nào trên a trong hàm thực sự đang sửa đổi biến x bên ngoài hàm. Bất kỳ thay đổi nào trên b đều sửa đổi y và bất kỳ thay đổi nào trên c đều sửa đổi z . Đó là lý do tại sao khi, trong ví dụ, hàm lặp lại sửa đổi giá trị của các biến a , b c , các giá trị của x , y z bị ảnh hưởng.

Nếu thay vì xác định trùng lặp là:

   
  void trùng lặp (int & amp; a, int & amp; b, int & amp; c)  

Nó có được xác định mà không có dấu và là:

   
  void trùng lặp (int a, int b, int c)  

Các biến sẽ không được chuyển, nhưng thay vào đó, tạo các bản sao của các giá trị của chúng. Trong trường hợp này, đầu ra của chương trình sẽ là các giá trị của x , y z mà không bị sửa đổi (tức là 1, 3 và 7).

Trong các hàm đã thấy trước đó, các đối số luôn được chuyển. Điều này có nghĩa là, khi gọi một hàm, những gì được truyền cho hàm là các giá trị của các đối số này tại thời điểm gọi, được sao chép vào các biến được đại diện bởi các tham số hàm. Ví dụ, lấy: Trong trường hợp này, phép cộng hàm được chuyển 5 và 3, là bản sao của các giá trị của và, tương ứng. Các giá trị này (5 và 3) được sử dụng để khởi tạo các biến được đặt làm tham số trong định nghĩa của hàm, nhưng bất kỳ sửa đổi nào của các biến này trong hàm đều không ảnh hưởng đến giá trị của các biến x và y bên ngoài nó, bởi vì x và y là Bản thân chúng không được truyền cho hàm trong cuộc gọi mà chỉ là bản sao của các giá trị của chúng tại thời điểm đó. Để làm điều đó, các đối số có thể được chuyển, thay vì. Ví dụ: hàm functionin mã này sao chép giá trị của ba đối số của nó, khiến các biến được sử dụng làm đối số thực sự bị sửa đổi bởi lệnh gọi: Để có quyền truy cập vào các đối số của nó, hàm khai báo các tham số của nó là. Trong C ++, các tham chiếu được biểu thị bằng dấu và () theo sau kiểu tham số, như trong các tham số được lấy bởi trong ví dụ trên. tham số hàm, trở nên được liên kết bằng cách nào đó với đối số được truyền vào hàm và bất kỳ sửa đổi nào trên các biến cục bộ tương ứng của chúng trong hàm đều được phản ánh trong các biến được truyền dưới dạng đối số trong lệnh gọi. hàm gọi (và) và bất kỳ thay đổi nào bên trong hàm thực sự đang sửa đổi biến bên ngoài hàm. Bất kỳ thay đổi nào sẽ sửa đổi và bất kỳ thay đổi nào sẽ sửa đổi. Đó là lý do tại sao khi, trong ví dụ, hàm sửa đổi các giá trị của các biến và, các giá trị của và bị ảnh hưởng. , thay vào đó tạo ra các bản sao của các giá trị của chúng. Trong trường hợp này, đầu ra của chương trình sẽ là các giá trị của và không được sửa đổi (tức là 1, 3 và 7).

Cân nhắc về hiệu quả và tham chiếu hằng số

Việc gọi một hàm với các tham số được lấy bởi giá trị sẽ tạo ra các bản sao của các giá trị. Đây là một hoạt động tương đối rẻ tiền đối với các loại cơ bản như int , nhưng nếu tham số thuộc loại phức hợp lớn, nó có thể dẫn đến một số chi phí nhất định. Ví dụ: hãy xem xét chức năng sau:

  1 
2
3
4
  chuỗi nối (chuỗi a, chuỗi b)
{
  trả về a + b;
}  

Hàm này nhận hai chuỗi làm tham số (theo giá trị) và trả về kết quả của việc nối chúng. Bằng cách truyền các đối số theo giá trị, hàm buộc a b là bản sao của các đối số được truyền cho hàm khi nó được gọi. Và nếu đây là các chuỗi dài, điều đó có thể có nghĩa là sao chép số lượng lớn dữ liệu chỉ cho lệnh gọi hàm.

Nhưng có thể tránh hoàn toàn việc sao chép này nếu cả hai tham số được tạo:

  1 
2
3
4
  chuỗi nối (chuỗi & amp; a, chuỗi & amp; b)
{
  trả về a + b;
}  

Lập luận bằng cách tham khảo không yêu cầu bản sao. Hàm hoạt động trực tiếp trên (bí danh của) các chuỗi được truyền dưới dạng đối số và nhiều nhất, nó có thể có nghĩa là chuyển các con trỏ nhất định đến hàm. Về vấn đề này, phiên bản nối lấy tham chiếu hiệu quả hơn phiên bản lấy giá trị, vì nó không cần sao chép các chuỗi đắt tiền để sao chép.

Mặt khác, các hàm có tham số tham chiếu thường được coi là hàm sửa đổi các đối số được truyền vào, bởi vì đó là lý do tại sao các tham số tham chiếu thực sự dành cho.

Giải pháp là để hàm đảm bảo rằng các tham số tham chiếu của nó sẽ không bị hàm này sửa đổi. Điều này có thể được thực hiện bằng cách xác định các tham số là hằng số:

  1 
2
3
4
  chuỗi nối (const string & amp; a, const string & amp; b)
{
  trả về a + b;
}  

Bằng cách xác định chúng là const , hàm bị cấm sửa đổi các giá trị của a hay b , nhưng thực sự có thể truy cập các giá trị của chúng dưới dạng tham chiếu ( bí danh của các đối số), mà không cần phải tạo bản sao thực của chuỗi.

Do đó, constTham chiếu cung cấp chức năng tương tự như truyền đối số theo giá trị, nhưng tăng hiệu quả cho các tham số kiểu lớn. Đó là lý do tại sao chúng cực kỳ phổ biến trong C ++ cho các đối số của các kiểu ghép. Tuy nhiên, lưu ý rằng đối với hầu hết các loại cơ bản, không có sự khác biệt đáng chú ý về hiệu quả và trong một số trường hợp, tham chiếu const thậm chí có thể kém hiệu quả hơn!

Việc gọi một hàm với các tham số được lấy bởi giá trị sẽ tạo ra các bản sao của các giá trị. Đây là một hoạt động tương đối rẻ tiền đối với các loại cơ bản, nhưng nếu tham số thuộc loại hợp chất lớn, nó có thể dẫn đến một số chi phí nhất định. Ví dụ, hãy xem xét hàm sau: Hàm này nhận hai chuỗi làm tham số (theo giá trị) và trả về kết quả của việc nối chúng. Bằng cách truyền các đối số theo giá trị, hàm buộc và phải là bản sao của các đối số được truyền cho hàm khi nó được gọi. Và nếu đây là các chuỗi dài, nó có thể có nghĩa là sao chép số lượng lớn dữ liệu chỉ cho lệnh gọi hàm. Tuy nhiên, có thể tránh hoàn toàn việc sao chép này nếu cả hai tham số đều được thực hiện. Hàm hoạt động trực tiếp trên (bí danh của) các chuỗi được truyền dưới dạng đối số và nhiều nhất, nó có thể có nghĩa là chuyển các con trỏ nhất định đến hàm. Về mặt này, phiên bản thực hiện tham chiếu hiệu quả hơn phiên bản lấy giá trị, vì nó không cần sao chép các chuỗi đắt tiền để sao chép. , bởi vì đó là lý do tại sao các tham số tham chiếu thực sự dành cho. Giải pháp là để hàm đảm bảo rằng các tham số tham chiếu của nó sẽ không bị hàm này sửa đổi. Điều này có thể được thực hiện bằng cách định tính các tham số là không đổi: Bằng cách cho phép chúng là hằng số, hàm bị cấm sửa đổi giá trị của các tham số không, nhưng thực sự có thể truy cập các giá trị của chúng dưới dạng tham chiếu (bí danh của các đối số), mà không cần phải tạo bản sao thực của Do đó, các tham chiếu cung cấp chức năng tương tự như truyền các đối số theo giá trị, nhưng với hiệu quả cao hơn cho các tham số kiểu lớn. Đó là lý do tại sao chúng cực kỳ phổ biến trong C ++ cho các đối số của các kiểu ghép. Tuy nhiên, lưu ý rằng đối với hầu hết các loại cơ bản, không có sự khác biệt đáng chú ý về hiệu quả và trong một số trường hợp, tham chiếu const thậm chí có thể kém hiệu quả hơn!

Các hàm nội tuyến

Việc gọi một hàm thường gây ra một số chi phí nhất định (xếp chồng đối số, bước nhảy, v.v.) và do đó đối với các hàm rất ngắn, có thể hiệu quả hơn nếu chỉ cần chèn mã của hàm vào nơi nó được gọi, thay vì thực hiện quy trình chính thức gọi một hàm.

Trước khai báo hàm với thông số inline thông báo cho trình biên dịch rằng mở rộng nội tuyến được ưu tiên hơn cơ chế gọi hàm thông thường cho một hàm cụ thể. Điều này hoàn toàn không thay đổi hành vi của một hàm, nhưng chỉ được sử dụng để đề xuất trình biên dịch rằng mã được tạo bởi thân hàm sẽ được chèn vào mỗi điểm hàm được gọi, thay vì được gọi bằng một lệnh gọi hàm thông thường. < br />

Ví dụ: hàm nối ở trên có thể được khai báo nội dòng là:

  1 
2
3
4
  chuỗi nội tuyến nối (const string & amp; a, const string & amp; b)
{
  trả về a + b;
}  

Điều này thông báo cho trình biên dịch rằng khi concatenate được gọi, chương trình thích hàm được mở rộng nội dòng, thay vì thực hiện một lệnh gọi thông thường. inline chỉ được chỉ định trong khai báo hàm, không phải khi nó được gọi.

Lưu ý rằng hầu hết các trình biên dịch đã tối ưu hóa mã để tạo các hàm nội tuyến khi họ thấy cơ hội để cải thiện hiệu quả, ngay cả khi không được đánh dấu rõ ràng bằng trình thông số inline . Do đó, chỉ định này chỉ đơn thuần chỉ ra trình biên dịch mà nội tuyến được ưu tiên cho chức năng này, mặc dù trình biên dịch có thể tự do không nội tuyến và tối ưu hóa theo cách khác. Trong C ++, tối ưu hóa là một nhiệm vụ được ủy quyền cho trình biên dịch, có thể tự do tạo bất kỳ mã nào miễn là hành vi kết quả là hành vi được chỉ định bởi mã.

Việc gọi một hàm thường gây ra một chi phí nhất định (xếp chồng đối số, bước nhảy, v.v.) và do đó đối với các hàm rất ngắn, có thể hiệu quả hơn nếu chỉ cần chèn mã của hàm vào nơi nó được gọi, thay vì Thực hiện quá trình chính thức gọi một hàm. Bắt đầu một khai báo hàm với bộ định nghĩa thông báo cho trình biên dịch rằng mở rộng nội tuyến được ưu tiên hơn cơ chế gọi hàm thông thường cho một hàm cụ thể. Điều này hoàn toàn không thay đổi hành vi của một hàm, mà chỉ được sử dụng để gợi ý cho trình biên dịch rằng mã do phần thân hàm tạo ra sẽ được chèn vào mỗi điểm hàm được gọi, thay vì được gọi bằng một lệnh gọi hàm thông thường. ví dụ, hàm nối ở trên có thể được khai báo nội tuyến như sau: Điều này thông báo cho trình biên dịch rằng whenis đã gọi, chương trình thích hàm được mở rộng nội tuyến, thay vì thực hiện một lệnh gọi thông thường. nó chỉ được chỉ định trong khai báo hàm, không phải khi nó được gọi .Lưu ý rằng hầu hết các trình biên dịch đã tối ưu hóa mã để tạo các hàm nội tuyến khi họ thấy cơ hội để cải thiện hiệu quả, ngay cả khi không được đánh dấu rõ ràng bằng mã định danh. Do đó, chỉ định này chỉ đơn thuần chỉ ra trình biên dịch mà nội tuyến được ưu tiên cho chức năng này, mặc dù trình biên dịch có thể tự do không nội tuyến và tối ưu hóa theo cách khác. Trong C ++, tối ưu hóa là một nhiệm vụ được ủy quyền cho trình biên dịch, có thể tự do tạo bất kỳ mã nào miễn là hành vi kết quả là hành vi được chỉ định bởi mã.

Giá trị mặc định trong các tham số

Trong C ++, các hàm cũng có thể có các tham số tùy chọn mà không yêu cầu đối số nào trong lệnh gọi, theo cách đó, ví dụ, một hàm có ba tham số chỉ có thể được gọi với hai. Đối với điều này, hàm phải bao gồm một giá trị mặc định cho tham số cuối cùng của nó, giá trị này được hàm sử dụng khi được gọi với ít đối số hơn. Ví dụ:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  // giá trị mặc định trong các hàm
#include & lt; iostream & gt;
sử dụng không gian tên std;

int split (int a, int b = 2)
{
  int r;
  r = a / b;
  return (r);
}

int main ()
{
  cout & lt; & lt; chia (12) & lt; & lt; '\N';
  cout & lt; & lt; chia (20,4) & lt; & lt; '\N';
  trả về 0;
}  
 6
5 

Trong ví dụ này, có hai lệnh gọi hàm chia . Trong phần đầu tiên:

   
  chia (12)  

Lời gọi chỉ truyền một đối số cho hàm, mặc dù hàm có hai tham số. Trong trường hợp này, hàm giả sử tham số thứ hai là 2 (lưu ý định nghĩa hàm, khai báo tham số thứ hai của nó là int b = 2 ). Do đó, kết quả là 6.

Trong cuộc gọi thứ hai:

   
  chia (20,4)  

Lời gọi chuyển hai đối số cho hàm. Do đó, giá trị mặc định cho b ( int b = 2 ) bị bỏ qua và b nhận giá trị được truyền làm đối số, đó là 4, mang lại kết quả là 5.

Trong C ++, các hàm cũng có thể có các tham số tùy chọn mà không yêu cầu đối số trong lệnh gọi, theo cách mà ví dụ, một hàm có ba tham số chỉ có thể được gọi với hai. Đối với điều này, hàm phải bao gồm một giá trị mặc định cho tham số cuối cùng của nó, giá trị này được hàm sử dụng khi được gọi với ít đối số hơn. Ví dụ: Trong ví dụ này, có hai lệnh gọi hàm. Trong cách đầu tiên: Lệnh gọi chỉ truyền một đối số cho hàm, mặc dù hàm có hai tham số. Trong trường hợp này, hàm giả sử tham số thứ hai là 2 (lưu ý định nghĩa hàm, khai báo tham số thứ hai của nó là). Do đó, kết quả là 6. Trong lần gọi thứ hai: Lời gọi chuyển hai đối số cho hàm. Do đó, giá trị mặc định cho) bị bỏ qua và lấy giá trị được truyền làm đối số, đó là 4, mang lại kết quả là 5.

Khai báo các hàm

Trong C ++, số nhận dạng chỉ có thể được sử dụng trong các biểu thức sau khi chúng đã được khai báo. Ví dụ: một số biến x không thể được sử dụng trước khi được khai báo với một câu lệnh, chẳng hạn như:

   
  int x;  

Điều tương tự cũng áp dụng cho các chức năng. Các hàm không thể được gọi trước khi chúng được khai báo. Đó là lý do tại sao, trong tất cả các ví dụ về hàm trước đây, các hàm luôn được định nghĩa trước hàm main , là hàm mà từ đó các hàm khác được gọi. Nếu main được xác định trước các hàm khác, điều này sẽ phá vỡ quy tắc mà các hàm phải được khai báo trước khi được sử dụng và do đó sẽ không được biên dịch.

Nguyên mẫu của một hàm có thể được khai báo mà không thực sự xác định hoàn toàn hàm, chỉ cung cấp đủ chi tiết để cho phép biết các kiểu liên quan đến một lệnh gọi hàm. Đương nhiên, hàm sẽ được định nghĩa ở một nơi khác, như sau trong đoạn mã. Nhưng ít nhất, một khi được khai báo như vậy, nó đã có thể được gọi.

Khai báo phải bao gồm tất cả các kiểu liên quan (kiểu trả về và kiểu đối số của nó), sử dụng cú pháp tương tự như được sử dụng trong định nghĩa của hàm, nhưng thay thế phần thân của hàm (khối câu lệnh) bằng dấu chấm phẩy kết thúc.

Danh sách tham số không cần phải bao gồm tên tham số mà chỉ cần loại của chúng. Tuy nhiên, tên tham số có thể được chỉ định, nhưng chúng là tùy chọn và không nhất thiết phải khớp với tên trong định nghĩa hàm. Ví dụ: một hàm có tên là protoosystem với hai tham số int có thể được khai báo bằng một trong hai câu lệnh sau:

  1 
2
  int proto Chức năng (int đầu tiên, int thứ hai);
chức năng int (int, int);  

Dù sao, bao gồm tên cho mỗi tham số luôn cải thiện tính dễ đọc của khai báo.

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
>
  // khai báo nguyên mẫu hàm
#include & lt; iostream & gt;
sử dụng không gian tên std;

void lẻ (int x);
void chẵn (int x);

int main ()
{
  int i;
  làm {
    cout & lt; & lt; "Vui lòng nhập số (0 để thoát):";
    cin & gt; & gt; tôi;
    lẻ (i);
  } while (i! = 0);
  trả về 0;
}

void lẻ (int x)
{
  if ((x% 2)! = 0) cout & lt; & lt; "Thật là kỳ lạ. \ N";
  else chẵn (x);
}

void Even (int x)
{
  if ((x% 2) == 0) cout & lt; & lt; "Nó thậm chí. \ N";
  khác lẻ (x);
}  
 Vui lòng nhập số (0 để thoát): 9
Nó là số lẻ.
Vui lòng nhập số (0 để thoát): 6
Nó thậm chí.
Vui lòng nhập số (0 để thoát): 1030
Nó thậm chí.
Vui lòng nhập số (0 để thoát): 0
Nó thậm chí. 

Ví dụ này thực sự không phải là một ví dụ về hiệu quả. Bạn có thể viết cho mình một phiên bản của chương trình này với một nửa số dòng mã. Dù sao, ví dụ này minh họa cách các hàm có thể được khai báo trước định nghĩa của nó:

Các dòng sau:

  1 
2
  void retail (int a);
void Even (int a);  

Khai báo nguyên mẫu của các hàm. Chúng đã chứa tất cả những gì cần thiết để gọi chúng, tên của chúng, kiểu đối số và kiểu trả về của chúng ( void trong trường hợp này). Với các khai báo nguyên mẫu này, chúng có thể được gọi trước khi chúng được định nghĩa hoàn toàn, ví dụ, cho phép đặt hàm từ nơi chúng được gọi ( main ) trước định nghĩa thực tế của các hàm này.


Nhưng việc khai báo các hàm trước khi được định nghĩa không chỉ hữu ích để sắp xếp lại thứ tự các hàm trong mã. Trong một số trường hợp, chẳng hạn như trong trường hợp cụ thể này, ít nhất một trong các khai báo là bắt buộc, vì lẻ chẵn được gọi lẫn nhau; có một lệnh gọi đến chẵn trong lẻ và một lệnh gọi đến lẻ trong chẵn . Và do đó, không có cách nào để cấu trúc mã sao cho lẻ được xác định trước chẵn chẵn trước lẻ .

Trong C ++, số nhận dạng chỉ có thể được sử dụng trong các biểu thức sau khi chúng đã được khai báo. Ví dụ, một số biến không thể được sử dụng trước khi được khai báo với một câu lệnh, chẳng hạn như: Điều tương tự cũng áp dụng cho các hàm. Các hàm không thể được gọi trước khi chúng được khai báo. Đó là lý do tại sao, trong tất cả các ví dụ trước đây về hàm, các hàm luôn được định nghĩa trước hàm, đó là hàm mà từ đó các hàm khác được gọi. Nếu được định nghĩa trước các hàm khác, điều này sẽ phá vỡ quy tắc rằng các hàm phải được khai báo trước khi được sử dụng và do đó sẽ không được biên dịch. tham gia vào một lệnh gọi hàm được biết đến. Đương nhiên, hàm sẽ được định nghĩa ở một nơi khác, như sau trong đoạn mã. Nhưng ít nhất, một khi được khai báo như vậy, nó đã có thể được gọi. phần nội dung của hàm (khối câu lệnh) có dấu chấm phẩy kết thúc. Danh sách tham số không cần bao gồm tên tham số mà chỉ có kiểu của chúng. Tuy nhiên, tên tham số có thể được chỉ định, nhưng chúng là tùy chọn và không nhất thiết phải khớp với tên trong định nghĩa hàm. Ví dụ, một hàm được gọi với hai tham số int có thể được khai báo bằng một trong hai câu lệnh sau: Dù sao, bao gồm tên cho mỗi tham số luôn cải thiện tính dễ đọc của khai báo. Ví dụ này thực sự không phải là một ví dụ về hiệu quả. Bạn có thể viết cho mình một phiên bản của chương trình này với một nửa số dòng mã. Dù sao, ví dụ này minh họa cách các hàm có thể được khai báo trước định nghĩa của nó: Các dòng sau: Khai báo nguyên mẫu của các hàm. Chúng đã chứa tất cả những gì cần thiết để gọi chúng, tên của chúng, kiểu đối số của chúng và kiểu trả về của chúng (trong trường hợp này). Với các khai báo nguyên mẫu này, chúng có thể được gọi trước khi chúng được định nghĩa hoàn toàn, ví dụ, cho phép đặt hàm từ nơi chúng được gọi () trước định nghĩa thực sự của các hàm này. để sắp xếp lại thứ tự của các chức năng trong mã. Trong một số trường hợp, chẳng hạn như trong trường hợp cụ thể này, ít nhất một trong các bản kê khai được yêu cầu, vì buồn nôn và được gọi chung; có một cuộc gọi kết thúc một cuộc gọi đến. Và, do đó, không có cách nào để cấu trúc mã như đã được định nghĩa trước đó và trước đó

Tính đệ quy

Tính đệ quy là thuộc tính mà các hàm phải được gọi bởi chính chúng. Nó hữu ích cho một số tác vụ, chẳng hạn như sắp xếp các phần tử hoặc tính giai thừa của các số. Ví dụ: để lấy giai thừa của một số ( n! ), công thức toán học sẽ là:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

Cụ thể hơn, 5! (giai thừa của 5) sẽ là:

5! = 5 * 4 * 3 * 2 * 1 = 120

Và một hàm đệ quy để tính toán điều này trong C ++ có thể là:

  1 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  // máy tính giai thừa
#include & lt; iostream & gt;
sử dụng không gian tên std;

giai thừa dài (dài a)
{
  nếu (a & gt; 1)
   return (a * giai thừa (a-1));
  khác
   trả về 1;
}

int main ()
{
  số dài = 9;
  cout & lt; & lt; số & lt; & lt; "! =" & lt; & lt; giai thừa (số);
  trả về 0;
}  
 9! = 362880 

Lưu ý rằng trong giai thừa hàm, chúng ta đã bao gồm một lệnh gọi đến chính nó, nhưng chỉ khi đối số được truyền lớn hơn 1, vì nếu không, hàm sẽ thực hiện một vòng lặp đệ quy vô hạn, trong đó khi nó đến 0, nó sẽ tiếp tục nhân với tất cả các số âm (có thể gây ra tràn ngăn xếp vào một thời điểm nào đó trong thời gian chạy).

Tính đệ quy là thuộc tính mà các hàm phải được gọi bởi chính chúng. Nó hữu ích cho một số tác vụ, chẳng hạn như sắp xếp các phần tử hoặc tính giai thừa của các số. Ví dụ, để có được giai thừa của một số (), công thức toán học sẽ là: Cụ thể hơn, (giai thừa của 5) sẽ là: Và một hàm đệ quy để tính toán điều này trong C ++ có thể là: một lệnh gọi đến chính nó, nhưng chỉ khi đối số được truyền lớn hơn 1, vì nếu không, hàm sẽ thực hiện một vòng lặp đệ quy vô hạn, trong đó khi nó đến 0, nó sẽ tiếp tục nhân với tất cả các số âm (có thể dẫn đến một tràn ngăn xếp tại một số điểm trong thời gian chạy).


Xem thêm những thông tin liên quan đến chủ đề cách viết một hàm trong c ++

Hàm và cách sử dụng hàm trong C++

  • Tác giả: Lập Trình Không Khó
  • Ngày đăng: 2020-03-15
  • Đánh giá: 4 ⭐ ( 2860 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Trong bài học số 20 của khóa học, chúng ta sẽ bắt đầu tìm hiểu về hàm trong C++. Đây là một level mới trong việc học code, từ đây code của chúng ta sẽ sáng sủa và đẹp hơn rất nhiều.

    Bài đọc thêm: https://nguyenvanhieu.vn/ham-trong-c/
    Bài tập thực hành: https://nguyenvanhieu.vn/bai-tap-c-co-loi-giai/

    Hãy like, đăng ký kênh, để lại những nhận xét cũng như giới thiệu khóa học cho bạn bè của mình để ủng hộ cho Lập Trình Không Khó nhé các bạn!
    =====================
    Kết nối với Lập Trình Không Khó
    Website: http://nguyenvanhieu.vn/
    Facebook: https://fb.com/groups/LapTrinhKhongKho
    Email: hieunv.dev@gmail.com

    laptrinhkhongkho hoccpp cppcoban

Cách viết hàm và cách gọi hàm trong C++ (function)

  • Tác giả: freetuts.net
  • Đánh giá: 4 ⭐ ( 8199 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Cách viết hàm trong C++, qua bài học bạn sẽ hiểu khái niệm hàm là gì cũng như cách gọi hàm trong C++ , xem các ví dụ về tạo hàm C++ chi tiết tại đây

Hàm trong C++, cú pháp và cách sử dụng

  • Tác giả: thuthuat.taimienphi.vn
  • Đánh giá: 3 ⭐ ( 4021 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: ham trong c++, Hàm trong C++, cú pháp và cách sử dụng

Ưu điểm của sử dụng hàm trong lập trình

  • Tác giả: nguyenvanhieu.vn
  • Đánh giá: 3 ⭐ ( 2823 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Trong bài học này, Lập trình không khó sẽ hướng dẫn các bạn các kiến thức căn bản nhất về hàm trong C: lý do tại sao nên dùng hàm, cách hàm hoạt động, …

Hàm trong C++

  • Tác giả: viettuts.vn
  • Đánh giá: 5 ⭐ ( 3694 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Một hàm là một nhóm các câu lệnh cùng nhau thực hiện một nhiệm vụ. Mỗi chương trình C++ có ít nhất một hàm, là hàm main(). Định nghĩa hàm trong C++ như sau.

Cách viết Clean Code trong lập trình C với vi điều khiển

  • Tác giả: khuenguyencreator.com
  • Đánh giá: 3 ⭐ ( 2437 lượt đánh giá )
  • Khớp với kết quả tìm kiếm: Code Rules and Styles trong lập trình C là các luật người lập trình tự đặt ra để đảm bảo tính sạch sẽ cho code (Clean Code)

Nguyên mẫu hàm trong C/C++ là gì? Và cách sử dụng – Minh Hoàng Blog

  • Tác giả: minhhn.com
  • Đánh giá: 5 ⭐ ( 4633 lượt đánh giá )
  • Khớp với kết quả tìm kiếm:

Xem thêm các bài viết khác thuộc chuyên mục: Kiến thức lập trình

Xem Thêm  Sass: Kiến thức cơ bản về Sass - làm thế nào để học sass

By ads_php