C++初学者指南第一步---9.函数

C++初学者指南第一步—9.函数

1.输入和输出

1.1第一个例子

计算两个数的平均值函数

double mean (double a, double b) {
  return (a + b) / 2;
}
int main () {
  std::cout << mean(2, 6) <<'\n';  // prints 4
}

• 封装实现细节
• 通过将问题分解为单独的函数，更容易对正确性和测试进行推理
• 避免重复常见任务的代码
  

// "call" at "call site"，在“调用点”调用函数
auto result = name(argument1, argument2);

1.2返回类型

返回类型可以是任何值：int、double、…	或者为"空"：void
double square (double x) { return (x * x); } int max (int x, int y) { if (x > y) return x; else return y; }	void print_squares (int n) { for (int i = 1; i <= n; ++i) cout << square(i) << ‘\n’; }

完整返回类型推导 (C++14)（推导 = 编译器自动确定类型）

auto foo (int i, double d) {
  …
  return i;
}
//  正确： 返回类型: int

auto foo (int i, double d) {
  return i;  //  int
  …
  return d;  //  double
} 
//  错误： 返回类型不一致！

1.3函数参数

• 无参数：f( )
• 一个或多个参数：g(int a, double b, int c, …)
• 参数名称在参数列表中必须是唯一的，即参数名称不能重复

常量参数

int foo (int a, int const b) {
  a += 5;   // 
  b += 10;  //  编译错误: 不能改变常量参数
  return (a + b);
}
// 调用foo:
foo(2,9);  // 常量不影响这里

• 传递给foo的任何第二个参数都将被复制到本地变量b中，b是const的事实在foo之外无效。
  注意：如果在函数内部不需要或者不允许改变参数的数值，那就把它们设置成 const 吧！

默认值参数

double f (double a, double b = 1.5) {
  return (a * b);
}
int main () {
  cout <<  f(2);     // 1个参数  → 3.0
  cout <<  f(2, 3);  // 2个参数  → 6.0
}
void foo (int i = 0);  //正确
void foo (int n, double x = 2.5);  //正确
void foo (int a, int b = 1, float c = 3.5f);  //正确
void foo (int a, int b = 1, int c );  //错误

注意：第一个默认值参数后面的每个参数也必须有默认值

1.4函数重载

• 名称相同但参数列表不同的函数
• 无法仅靠返回类型重载

正确重载
名称相同，不同参数列表

int abs (int i) {
  return ((i < 0) ? -i : i);
}

double abs (double d) {
  return ((d < 0.0) ? -d : d);
}
int a = -5;
double b = -2.23;
auto x = abs(a); // int abs(int)
auto y = abs(b); // double abs(double)

错误重载
名称相同，相同参数列表

int foo (int i) {  //错误
  return (2 * i);
}

double foo (int i) { //错误
  return (2.5 * i);
}

无法编译！

2.函数执行

2.1递归

递归 = 函数调用自身

• 需要一个中断条件
• 看起来比循环更优雅，但在许多情况下速度更慢
• 递归的深度有限制（受栈大小限制）

int factorial (int n) {
    // 中断条件:
    if (n < 2) return 1;  
    // 递归调用： n! = n * (n-1)!
    return (n * factorial(n - 1));  
}

2.2 声明和定义

• 只能调用已知的函数（在之前/上方已知）。
• 每个源文件（翻译单元）只允许一个定义。
• 任意数量的函数声明都可以 = 通过指定函数的签名来宣布函数的存在。

错误例子：
COMPILER ERROR: - ‘odd’/‘even’ not known before ‘main’!
COMPILER ERROR: - ‘odd’ not known before ‘even’!

int main () {
 int i = 0;
 cin >> i;
 if (odd(i))  cout << "is odd\n";
 if (even(i)) cout << "is even\n";
}
bool even (int n) {
 return !odd(n);
}
bool odd (int n) {
 return (n % 2);
}

正确例子：

bool even (int);  // declaration
bool odd (int);   // declaration
int main () {     // definition of 'main'
  int i = 0; 
  cin >> i;
  if (odd(i))  cout << "is odd\n";   // OK, already declared
  if (even(i)) cout << "is even\n";  // OK, already declared
}
bool even (int n) { // definition of 'even'
  return !odd(n);  // OK, already declared
}
bool odd (int n) {  // definition of 'odd'
  return (n % 2);
}

3.函数设计

== 接口应该易于正确使用，难以错误使用。 —斯科特·迈耶斯—==

3.1约定

设计函数时请考虑：

• 前提条件：您对输入值有何期望/要求？
• 后置条件：对于输出值你应该给出什么保证？
• 不变量：函数的调用者/用户希望不改变什么？
• 目的：您的函数有明确定义的目的吗？
• 名称：函数的名称是否反映了其用途？
• 参数：调用者/用户是否容易混淆它们的含义？

前提条件检查

• 广契约函数执行前提条件检查，即检查输入参数值(或程序状态)的有效性。
• 窄契约函数不执行前置检查，即，调用者必须确保输入参数（以及程序状态）有效。

3.2 特性[[nodiscard]] （C++17）

鼓励编译器在函数返回值被丢弃时发出警告。

[[nodiscard]] bool prime (int i) { … }
// 返回值被使用:
bool const yes = prime(47);
if (prime(47)) { … }
// 返回值被丢弃/忽略:
prime(47);  //  编译警告

标准库中的示例：
std::vector的empty()函数在c++ 20中使用[[nodiscard]]声明，因为它可能与clear()混淆：

std::vector<int> v;
// …
if (v.empty()) { … }  // 正确
v.empty();  // C++20:  编译警告
// 哎呀...是不是有人想要清除它？

用[[nodiscard]]声明你的函数返回值：

• 如果在任何情况下不使用返回值都毫无意义
• 如果用户对其目的感到困惑，如果返回值被忽略。

3.3 不抛出异常保证：noexcept (C++11)

C++有一种像许多/大多数其他编程语言一样使用异常报告错误的机制。别担心，如果你不知道异常是什么，它们将在后面的章节中详细解释。
noexcept关键字指定一个函数承诺永远不会抛出异常/让异常逃逸：

void foo () noexcept { … }

如果异常从 noexcept 函数中逸出， 该程序将被中止。

4.一些常用数学函数

附上原文链接
如果文章对您有用，请随手点个赞，谢谢！^_^