Trong bài học trước, chúng ta đã học về hàm có thể trả về một giá trị cho người gọi hàm đó. Chúng ta đã sử dụng điều đó để tạo ra một hàm getValueFromUser mà chúng ta đã sử dụng trong chương trình này:

#include <iostream>
 
int getValueFromUser()
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input;
}
 
int main()
{
	int num { getValueFromUser() };
 
	std::cout << num << " doubled is: " << num * 2 << '\n';
 
	return 0;
}

Tuy nhiên, điều gì sẽ xảy ra nếu chúng ta muốn đầu ra của một hàm để cho vào một hàm khác? Bạn có thể thử một cái gì đó như thế này:

#include <iostream>
 
int getValueFromUser() // this function now returns an integer value
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input; // added return statement to return input back to the caller
}
 
// This function won't compile
// The void return type means the function won't return a value to the caller
void printDouble()
{
	std::cout << num << " doubled is: " << num * 2 << '\n';
}
 
int main()
{
	int num { getValueFromUser() };
 
	printDouble();
 
	return 0;
}

Điều này đã không được biên dịch, vì hàm printDouble không biết định danh num là gì?. Bạn có thể thử định nghĩa num là một biến bên trong hàm printDouble():

void printDouble()
{
	int num{}; // we added this line
	std::cout << num << " doubled is: " << num * 2 << '\n';
}

Mặc dù điều này giải quyết lỗi của trình biên dịch và làm cho chương trình có thể biên dịch được, nhưng chương trình vẫn không hoạt động chính xác (nó luôn in ra 0 và 0 nhân đôi là 0). Cốt lõi của vấn đề ở đây là hàm printDouble không có cách truy cập giá trị mà người dùng đã nhập.

Chúng ta cần một số cách để truyền giá trị của num cho hàm printDouble để printDouble có thể sử dụng giá trị đó trong thân hàm của nó.

1. Các tham số và đối số

Trong nhiều trường hợp, Khi có thể truyền thông tin đến một hàm được gọi, để hàm đó có dữ liệu để làm việc. Ví dụ, nếu chúng ta muốn viết một hàm để thêm hai số, chúng ta cần một số cách để nói cho hàm biết về hai số sẽ thêm khi chúng ta gọi nó. Chúng ta làm điều đó thông qua các tham số của hàm và đối số.

Một tham số của hàm là một biến được sử dụng trong một hàm. Các tham số của hàm hoạt động gần như giống hệt với các biến được định nghĩa bên trong hàm, nhưng có một điểm khác biệt: chúng luôn được khởi tạo với một giá trị được cung cấp bởi người gọi của hàm.

Các tham số của hàm được định nghĩa trong khai báo hàm bằng cách đặt chúng ở giữa dấu ngoặc đơn sau tên hàm, với nhiều tham số được phân tách bằng dấu phẩy.

Dưới đây là một số ví dụ về các hàm với số lượng tham số khác nhau:

// This function takes no parameters
// It does not rely on the caller for anything
void doPrint()
{
    std::cout << "In doPrint()\n";
}
 
// This function takes one integer parameter named x
// The caller will supply the value of x
void printValue(int x)
{
    std::cout << x  << '\n';
}
 
// This function has two integer parameters, one named x, and one named y
// The caller will supply the value of both x and y
int add(int x, int y)
{
    return x + y;
}

Đối số là một giá trị được truyền từ người gọi đến hàm khi thực hiện lệnh gọi hàm:

doPrint(); // this call has no arguments
printValue(6); // 6 is the argument passed to function printValue()
add(2, 3); // 2 and 3 are the arguments passed to function add()

Lưu ý rằng nhiều đối số cũng được phân tách bằng dấu phẩy.

2. Làm thế nào các tham số và đối số làm việc với nhau

Khi một hàm được gọi, tất cả các tham số của hàm được tạo dưới dạng các biến và giá trị của từng đối số được sao chép một cách khớp vào tham số tương ứng. Quá trình này được gọi là gán giá trị vào(pass by value).

Ví dụ:

#include <iostream>
 
// This function has two integer parameters, one named x, and one named y
// The values of x and y are passed in by the caller
void printValues(int x, int y)
{
    std::cout << x << '\n';
    std::cout << y << '\n';
}
 
int main()
{
    printValues(6, 7); // This function call has two arguments, 6 and 7
 
    return 0;
}

Khi hàm printValues ​​được gọi với các đối số 6 và 7, tham số x của printValues được tạo và khởi tạo với giá trị 6 và tham số y của printValues được tạo và khởi tạo với giá trị 7.

Điều này dẫn đến kết quả đầu ra:

6
7

Lưu ý rằng số lượng đối số thường phải khớp với số lượng tham số hàm hoặc không thì trình biên dịch sẽ đưa ra lỗi. Đối số được truyền cho một hàm có thể là bất kỳ biểu thức hợp lệ nào (vì về cơ bản, đối số chỉ là một trình khởi tạo giá trị cho tham số và các khởi tạo có thể là bất kỳ biểu thức hợp lệ nào).

3. Sửa chữa chương trình này cùng chúng tôi

#include <iostream>
 
int getValueFromUser() // this function now returns an integer value
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input; // added return statement to return input back to the caller
}
 
void printDouble(int value)
{
	std::cout << value << " doubled is: " << value * 2 << '\n';
}
 
int main()
{
	int num { getValueFromUser() };
 
	printDouble(num);
 
	return 0;
}

Trong chương trình này, biến num đầu tiên được khởi tạo với giá trị được nhập bởi người dùng. Sau đó, hàm printDouble được gọi và giá trị của num được sao chép vào tham số giá trị của hàm printDouble. Hàm printDouble sau đó sử dụng giá trị của tham số đó.

4. Sử dụng giá trị trả về làm đối số

Trong bài toán trên, chúng ta có thể thấy rằng num chỉ được sử dụng một lần, để vận chuyển giá trị trả về của hàm getValueFromUser đến đối số của lệnh gọi hàm printDouble.

Chúng ta có thể đơn giản hóa ví dụ trên một chút như sau:

#include <iostream>
 
int getValueFromUser() // this function now returns an integer value
{
 	std::cout << "Enter an integer: ";
	int input{};
	std::cin >> input;  
 
	return input; // added return statement to return input back to the caller
}
 
void printDouble(int value)
{
	std::cout << value << " doubled is: " << value * 2 << '\n';
}
 
int main()
{
	printDouble(getValueFromUser());
 
	return 0;
}

Bây giờ, chúng ta sử dụng giá trị trả về của hàm getValueFromUser trực tiếp làm đối số cho hàm printDouble!

Mặc dù chương trình này ngắn gọn hơn, nhưng bạn cũng có thể thấy cú pháp rút gọn này có một chút khó đọc. Nếu bạn có thể thoải mái hơn khi sử dụng biến để lưu giá trị của hàm, thì đó là điều tốt.

5. Cảnh báo về thứ tự đối số của hàm

Đặc tả trong C ++ không định nghĩa rằng các đối số có khớp với các tham số theo thứ tự từ trái sang phải hoặc từ phải sang trái hay không. Khi sao chép giá trị, thứ tự là không thống nhất. Tuy nhiên, nếu các đối số là các lệnh gọi hàm, thì điều này có thể có vấn đề:

someFunction(a(), b()); // a() or b() may be called first

Nếu xem xét từ trái sang phải, a() sẽ được gọi trước b(). Nếu xem xét từ phải sang trái, b() sẽ được gọi trước a(). Điều này có thể có hoặc không có hậu quả, tùy thuộc vào những gì hàm a() và b() làm.

Nếu điều quan trọng với đối số, bạn nên xác định rõ thứ tự thực hiện, như vậy:

int avar{ a() }; // a() will always be called first
int bvar{ b() }; // b() will always be called second
 
someFunction(avar, bvar); // it doesn't matter whether avar or bvar are copied first because they are just values

Cảnh báo

Đặc tả trong C ++ không xác định liệu các hàm sẽ lấy các đối số từ trái sang phải hay phải sang trái. Do đó nên cẩn thận không thực hiện các cuộc gọi hàm ngay trong các đối số của hàm nào đó khi có vấn đề trong thứ tự gọi các hàm.

6. Làm thế nào các tham số và giá trị trả về làm việc cùng nhau

Bằng cách sử dụng cả tham số và giá trị trả về, chúng ta có thể tạo ra các hàm lấy dữ liệu làm đầu vào cho hàm khác, thực hiện một số tính toán với nó và trả về giá trị cho người gọi.

Dưới đây là một ví dụ về một hàm rất đơn giản, cộng hai số lại với nhau và trả về kết quả cho người gọi:

#include <iostream>
 
// add() takes two integers as parameters, and returns the result of their sum
// The values of x and y are determined by the function that calls add()
int add(int x, int y)
{
    return x + y;
}
 
// main takes no parameters
int main()
{
    std::cout << add(4, 5) << '\n'; // Arguments 4 and 5 are passed to function add()
    return 0;
}

Thực hiện bắt đầu chạy từ đầu hàm main. Khi add (4, 5) được thực hiện, hàm add được gọi, tham số x được khởi tạo với giá trị 4 và tham số y được khởi tạo với giá trị 5.

Câu lệnh return trong hàm add sẽ thực hiện x + y để tạo ra giá trị 9, sau đó được trả về hàm main. Giá trị 9 này sau đó được gửi đến std :: cout để được in lên console.

Đầu ra: 9

7. Thêm ví dụ

Hãy cùng xem một số cuộc gọi hàm khác:

#include <iostream>
 
int add(int x, int y)
{
    return x + y;
}
 
int multiply(int z, int w)
{
    return z * w;
}
 
int main()
{
    std::cout << add(4, 5) << '\n'; // within add() x=4, y=5, so x+y=9
    std::cout << add(1 + 2, 3 * 4) << '\n'; // within add() x=3, y=12, so x+y=15
 
    int a{ 5 };
    std::cout << add(a, a) << '\n'; // evaluates (5 + 5)
 
    std::cout << add(1, multiply(2, 3)) << '\n'; // evaluates 1 + (2 * 3)
    std::cout << add(1, add(2, 3)) << '\n'; // evaluates 1 + (2 + 3)
 
    return 0;
}

Chương trình này tạo đầu ra:

9
15
10
7
6

Câu lệnh đầu tiên khá đơn giản.

Trong câu lệnh thứ hai, các đối số là các biểu thức được thực hiện trước khi được thông qua. Trong trường hợp này, 1 + 2 ước tính thành 3, vì vậy 3 được sao chép vào tham số x. 3 * 4 ước tính thành 12, do đó 12 được sao chép vào tham số y. thêm (3, 12) giải quyết thành 15.

Cặp lệnh tiếp theo cũng tương đối dễ dàng:

int a{ 5 };
std::cout << add(a, a) << '\n'; // evaluates (5 + 5)

Trong trường hợp này, add() được gọi trong đó giá trị của a được sao chép vào cả hai tham số x và y. Vì a có giá trị 5, nên thêm (a, a) = add (5, 5), giá trị này sẽ thành giá trị 10.

Hãy cùng xem một câu lệnh khó hiểu đầu tiên trong nhóm:

    std::cout << add(1, multiply(2, 3)) << '\n'; // evaluates 1 + (2 * 3)

Khi hàm add được thực thi, chương trình cần xác định giá trị của tham số x và y là gì. x đơn giản vì chúng ta chỉ truyền cho nó số nguyên là 1. Để có được giá trị cho tham số y, trước tiên cần thực hiện bội số (2, 3). Chương trình gọi hàm nhân và khởi tạo z = 2 và w = 3, do đó nhân (2, 3) trả về giá trị nguyên 6. Giá trị trả về 6 đó hiện có thể được sử dụng để khởi tạo tham số y của hàm add. add (1, 6) trả về số nguyên 7, sau đó được chuyển đến std :: cout để in.

Đọc bằng lời:
thêm (1, nhân (2, 3)) ước tính để thêm (1, 6) ước tính thành 7

Câu lệnh sau có vẻ khó khăn vì một trong các tham số được cung cấp để thêm là một lệnh gọi hàm add khác.

 std::cout << add(1, add(2, 3)) << '\n'; // evaluates 1 + (2 + 3)

Nhưng trường hợp này hoạt động chính xác như trường hợp trước. add (2, 3) giải quyết trước, dẫn đến giá trị trả về là 5. Bây giờ nó có thể giải quyết add (1, 5), ước tính giá trị là 6, được chuyển đến std :: cout để in.

Nói bằng lời:
thêm (1, thêm (2, 3)) ước tính để thêm (1, 5) => ước tính thành 6

8. Phần kết luận

Các tham số của hàm và giá trị trả về là các cơ chế chính mà theo đó các hàm có thể được viết để có thể sử dụng lại, vì nó cho phép chúng ta viết các hàm có thể thực hiện các tác vụ và trả lại kết quả được truy xuất hoặc tính toán cho người gọi mà không cần biết đầu vào hoặc đầu ra cụ thể như thế nào.

Bạn thấy chất lượng bài viết này tốt không?

Thả 1->5 ❤️ để đánh giá chất lượng bài viết.

Xếp hạng 5 / 5. Số lượng đánh giá 1

Hãy đánh giá để ủng hộ và giúp chúng tôi cải thiện bài viết tốt hơn cho bạn!

Chúng tôi xin lỗi vì bài viết chưa được chất lượng. Chúng tôi sẽ cải thiện nó sớm nhất!

Hãy gửi phản hồi của bạn cho chúng tôi

Tại sao bài viết này lại không chất lượng?

Đăng ký kênh youtube để ủng hộ Cafedev nha các bạn, Thanks you!

1 BÌNH LUẬN

BÌNH LUẬN

Vui lòng nhập bình luận của bạn
Vui lòng nhập tên của bạn ở đây