函数调用时的栈

函数就是一个可调用的代码块. C++中把它归为可调用对象的一种, 而 Swift 中把函数归为一种特殊的闭包.

由于 C++包含了大部分的 C, 在它其中的函数形式有多种, 但都没有 Swift 中的函数简单强大: 简单是因为 Swift 中函数的形式都归为一种 —— 后置返回样式; 强大是因为 Swift 中函数可以嵌套 —— 函数中也可以定义函.，函数可以嵌套的玄机大概是闭包可以嵌套吧.

而 C++中相当于闭包的lamdba表达式实际上却是一个未命名类的未命名对象, 所以它也和C++的函数一样被 C++归为可调用对象的一种.(注意在 C++14对 lamdba 表达式作了优化升级)

所以, 看着这里, 你大概有一个基本的看法: ** lamdba 和 闭包根本就是两个东西, 但是在功能上, 它们的作用又很相似.** 注意名词: 匿名函数, lamdba, 闭包

形式	Swift	C++
函数	func关键字开头	C 风格函数和 auto 开头的尾置返回类型的函数: ->
闭包与 lamdba	符号{}创建闭包	**[捕获列表] (参数列表:可忽略) -> 返回类型:可忽略 {函数体} **

函数

Swift 中使用func 来声明一个函数,使用名字和参数来调用函数, 使用->来指定函数返回值的类型.

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet(person: "Bob", day: "Tuesday")

练习: 删除 day 参数，添加一个参数来表示今天吃了什么午饭。

默认情况下，函数使用它们的参数名称作为其参数的标签。 在参数名称前写入自定义参数标签，或者写入 _ 以使用无参数标签。

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

C++中的函数形式则跟经典的 C 函数没啥区别, C++11可以使用尾置返回类型,使用调用运算符()并传入必须的实参来执行函数, 唯一 没有 Swift给力的就是没有函数标签, 造成的结果就是一般来说阅读别人的代码很难推测出相应函数的功能:

#include <iostream>
#include <string>
using namespace std;

auto greet(string person, string day) -> string { // 使用尾置返回类型定义一个函数, auto 开头
    return "Hello " + person + ", today is " + day + ".";
}

int main() { // 这里的main 函数就是一个经典的有返无参的 C 风格函数
    
    greet("Bob", "Tuesday");
    
    return 0;
}

Swift 中可以使用元组来创建一个复合值, 比如说从一个函数中返回多个值. 元组中的元素可以通过名字或数字被引用:

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0

    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }

    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

C++中也可以使用元素来创建一个复合值, 利用它来返回多个值. 只是 C++元组的成员都是未命名的, 而且只能标准库模板函数get来引用其中的元素:

#include <iostream>
#include <tuple> // 包含 tuple 头文件来创建元组
#include <vector>

using namespace std;

auto calculateStatistics(vector<int> scores) -> tuple<int, int, int> { // 返回元组的函数
    auto min = scores[0];
    auto max = scores.front(); // 等同于scores[0]
    auto sum = 0;
    
    for (auto score : scores) {
        if (score > max) {
            max = score;
        }else if (score < min) {
            min = score;
        }
        sum += score;
    }
    
    return make_tuple(min, max, sum); // 可以使用 make_tuple 标准库函数生成元组对象
}

int main() {
    
    vector<int> scores = {5, 3, 100, 3, 9};
    auto statistics = calculateStatistics(scores);
    cout << get<2>(statistics) << endl; // 使用标准库函数模板来访问元组中的元素, 元组中的元素下标从0开始.
    
    return 0;
}

Swift 中的函数可以带有可变个数的参数, 这些参数在函数内表现为数组:

func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)

C++中的函数同样也可以带有可变个数的参数:

#include <iostream>
#include <initializer_list> // 包含initializer_list,来使用initializer_list类型定义含有可变形参的函数
using namespace std;

// 1, 所用实参类型相同, 可以使用initializer_list
auto sumOf(initializer_list<int> numbers = {}) -> int { // 此时参数都是 int 类型的值的序列, 可以在<>中间写入参数的类型, 其中 = {}为默认参数
    auto sum = 0;
    for (auto number : numbers) {
        sum += number;
    }
    return sum;
}

int main() {
    
    sumOf(); // 当函数没有传入任何实参时, 将使用默认参数
    sumOf({42, 597, 12}); // 在大括号中放入要传递的一个值的序列

    return 0;
}

练习: 分别用两种语言写一个计算参数平均值的函数。

Swift 中函数可以嵌套. 被嵌套的函数来重构一个太长或者太复杂的函数. 函数是一等类型, 这意味着函数可以作为另一个函数的返回值. 函数也可以当做参数传入另一个函数.

func returnFifteen() -> Int { 
    var y = 10
    func add() { // 一个函数可以嵌套在另一个函数中
        y += 5
    }
    add()
    return y
}
returnFifteen()

func makeIncrementer() -> ((Int) -> Int) { // 函数可以返回另一个函数
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)

func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool { // 函数的参数可以是一个函数
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)

C++中除了不能在一个函数内部嵌套定义函数之外, 它还不允许返回另一个函数、函数的参数也不能是函数 —— 尽管如此， 但是我们仍然可以返回指向函数的指针，带有指向函数的指针的形参来达到同样的目的：

#include <iostream>
#include <vector>

using namespace std;

auto add(int y) -> int {
     return y += 5;
}

auto returnFifteen(int y) -> int { // 函数不能嵌套, 但是函数内部仍然可以调用另一个函数
    return add(y);
}

auto addOne(int number) -> int {
    return 1 + number;
}

// 函数可以返回指向函数的指针
auto makeIncrementer() -> int (*) (int) { // int (*) (int) 为指向返回int, 带有一个参数为 int参数的函数指针
    return addOne;
}

auto lessThanTen(int number) -> bool {
    return number < 10;
}

// 函数可以带有指向函数的形参
auto hasAnyMatches(vector<int> list, decltype(lessThanTen) *condition) -> bool { // decltype(lessThanTen) 是得到一个函数的类型的简单方法, 注意此时只是得到函数的类型, 写函数指针则只需要在后面写个 * 即可
    for (auto item : list) {
        if (condition(item)) {
            return true;
        }
    }
    
    return false;
}

    
int main() {
    
    returnFifteen(10);
    
    auto increment  = makeIncrementer();
    increment(7);
    
    vector<int> numbers = {20, 19, 7, 12};
    hasAnyMatches(numbers, lessThanTen);
    
    return 0;
}

Swift 闭包 和 C++ lamdba 表达式

Swift 中函数实际上是一种特殊的闭包: 它是一段能够在之后被调用的代码.闭包中的代码能访问闭包所创建作用域中能得到的变量和函数, 即使闭包是在不同的作用域被执行的 —— 在嵌套函数例子中所看到的那样. 你可以使用{}来创建一个匿名的闭包. 使用in 进参数和返回值类型声明与闭包函数体进行分离:

numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
})

练习: 重写闭包，对所有奇数返回0。

有几种方法可以写简洁的闭包. 当闭包的类型已知—— 就像在代理的回调 —— 你可以忽略它的参数类型、返回值类型之一或者都忽略。而只有单独一条语句的闭包隐式地返回该语句的值:

let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)

你可以通过数字而不是通过名字来引用参数 —— 在非常短的闭包中非常有用. 当一个闭包作为最后一个参数传递给一个函数时, 它可以直接跟在括号后面. 当一个闭包是传给函数的唯一参数时, 你可以完全忽略括号:

let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)

C++中的 lamdba 表达式实际上是一个未命名类的未命名对象 —— 是一个可调用的函数对象.一个 lamdba 表达式表示一个可调用代码单元.形式如: [捕获列表] (参数列表) -> 返回类型 { 函数体 }, lamdba 必须使用尾置返回来指定返回类型. 虽然一个 lamdba 可以出现在一个函数中, 使用其局部变量, 但它只能使用那些明确指明的变量. lamdba 通过捕获列表来包含我们需要使用的局部变量, 当然我们可以让lamdba 隐式捕获变量, 在捕获列表中写一个&或=. &告诉编译器采用捕获引用方式, =告诉编译器采用值捕获方式,C++14已经给 lamdba 做出了升级和优化:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    
    auto otherCompareValue = 10;
    vector<int> numbers = {20, 19, 7, 12};
    sort(numbers.begin(), numbers.end(), [=](const int &a, const int &b) -> bool { // [=]表示采用值捕获方式, const int &a 中 &a 表示引用这个参数. 你可以把[=]中的=替换为otherCompareValue来明确指出我要捕获otherCompareValue这个局部变量.
        if (a < b && a < otherCompareValue) {
            cout << a << "小于" << otherCompareValue << endl;
        }
        return a < b;
    });
    
    for (auto i : numbers) {
        cout << i << " ";
    }
    
    return 0;
}```
我们可以忽略参数列表和返回类型, 但必须永远包含捕获列表和函数体.如果忽略返回类型, `lambda `根据函数体中的代码来推断出返回类型 —— 先别觉得它智能  —— 如果函数只是一个` return `语句, 则返回类型从返回的表达式推断而来, 否则返回类型为 `void`:

include <iostream>

using namespace std;

int main() {

auto f = [] {return 42;};
cout << f() << endl;

return 0;

}