swift——复合类型——函数——函数类型

最新推荐文章于 2024-12-13 14:05:37 发布

mardax

最新推荐文章于 2024-12-13 14:05:37 发布

阅读量338

点赞数

CC 4.0 BY-SA版权

分类专栏： swift 文章标签：函数类型函数类型参数函数类型返回值嵌套函数

本文链接：https://blog.youkuaiyun.com/mardax/article/details/72353169

swift 专栏收录该内容

19 篇文章

订阅专栏

本文探讨了Swift中的函数类型，包括它们如何作为返回类型和参数类型使用。函数类型的本质是一个元组，对于空元组可以使用Void或()表示，但不能省略。当元组仅有一个元素时，其括号可以是可选的，而多个元素时则不能省略。此外，函数类型在使用上与基本数据类型类似，可以被声明为常量或变量，并能进行类型推断。文中还提到了函数类型的参数和返回值，以及嵌套函数的概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

函数类型

函数类型由参数类型和返回类型组成

func feed()
{
    print("feed nothing")
}

func feed(rice: Int) -> Int
{
    print("feed rice \(rice)")
    return rice;
}

func feed(rice: Int, meat: Int) -> (Int, Int)
{
    print("feed rice \(rice) and meat \(meat)")
    return (rice, meat)
}

func use_functype()
{
    let feed0: () -> Void = feed
    let feed1: (Int) -> Int = feed
    let feed2: (Int, Int) -> (Int, Int) = feed
    
    feed0();
    feed1(5)
    feed2(5, 8)
}

output：

feed nothing
feed rice 5
feed rice 5 and meat 8

总结：

函数类型的返回类型本质为tuple，因此空tuple可用Void或()表示，但不可omit，只含单个成员tuple括号optional，包含多个成员tuple括号不可omit
函数类型的参数类型本质为tuple，因此空tuple可用Void或()表示，但不可omit，只含单个成员tuple括号optional，包含多个成员tuple括号不可omit
函数类型在使用上与普通类型(如Int)无任何区别，可使用let或var定义，亦可进行类型推断，只要不造成二义性error
函数名本质就是函数类型，只是常量(let)而已，函数定义时即进行了初始化，指向所定义函数

函数类型参数

func add(a: Int, _ b: Int) -> Int
{
    return a + b
}

func sub(a: Int, _ b: Int) -> Int
{
    return a - b
}

func arith(fun: (Int, Int) -> Int, _ a: Int, _ b: Int)
{
    print("result: \(fun(a, b))")
}

func functype_param()
{
    arith(add, 18, 8)
    arith(sub, 18, 8)
}

output：

result: 26
result: 10

函数类型返回值

func add(a: Int, _ b: Int) -> Int
{
    return a + b
}

func sub(a: Int, _ b: Int) -> Int
{
    return a - b
}

func arith(flag: Bool) -> (Int, Int) -> Int
{
    if(flag)
    {
        return add
    }
    else
    {
        return sub
    }
}

func functype_ret()
{
    let fun1 = arith(true)
    let fun2 = arith(false)
    
    print("result: \(fun1(18, 8))")
    print("result: \(fun2(18, 8))")
}

output：

result: 26
result: 10

嵌套函数

func arith(flag: Bool) -> (Int, Int) -> Int
{
    func add(a: Int, _ b: Int) -> Int
    {
        return a + b
    }
    
    func sub(a: Int, _ b: Int) -> Int
    {
        return a - b
    }
    
    if(flag)
    {
        return add
    }
    else
    {
        return sub
    }
}

func nested_func()
{
    let fun1 = arith(true)
    let fun2 = arith(false)
    
    print("result: \(fun1(18, 8))")
    print("result: \(fun2(18, 8))")
}

output：

result: 26
result: 10