函数定义和调用(C++/Java/Python)

C++

定义格式

返回值类型 函数名(参数列表)
{
函数主体;

}
其中，返回值类型可以是void(无返回值)，也可以是int、float、vector、bool、string等数据类型；
函数名命名规则和变量一样，参数是可选的

示例1：无参数、无返回

void fun0(){
    cout<<"fun0 running!"<<endl;
}
int main() {
    fun0();    //调用
    return 0;
}
// 输出：fun0 running!

示例2：有参数、返回一个整型值

int fun1(int a){    // 一个参数
    return a*a;     // 返回传入的数的平方
}
int fun2(int a, int b){ // 两个参数
    return a+b;         // 返回两数之和
}
int main() {
    int x,y;
    x = fun1(5);        // 返回5的平方
    y = fun2(3,4);      // 返回3+4
    cout<<x<<' '<<y<<endl;
    return 0;
}
// 输出：25 7

示例3：返回多个参数

用pair实现。
如果要返回3个或以上的值，类型相同用数组，类型不同用tuple。

pair<int, string> fun3(int a, string s){ // 传入一个数字和一个字符串
    int res1 = a*2;     // 数字*2
    string res2 = s+s;  // 字符串复制一遍
    pair<int, string> res(res1,res2);
    return res;
}
int main() {
    pair<int, string> temp;
    temp = fun3(5, "abc");
    int a = temp.first;
    string s = temp.second;
    cout<<a<<endl;
    cout<<s<<endl;
    return 0;
}
/*
输出：
10
abcabc
*/

示例4：参数有默认值

参数有默认值的时候，如果不传入该参数，则采用默认值。

int fun4(int a, int b = 100){ // 参数b有默认值100
    return a + b;
}
int main() {
    int res1 = fun4(5);       // 只传入一个参数，b采用默认值
    int res2 = fun4(5,10);    // 传入两个参数
    cout<<res1<<endl;         // 105
    cout<<res2<<endl;         // 15
    return 0;
}

示例5：定义在调用之后

如果函数调用的时候还未定义，则要先声明，声明格式为：返回值类型 函数名(参数列表);

int main() {
    int fun(int a, int b);  // 函数还未定义的时候调用，要先声明，否则会报错
    // int fun(int, int);   // 也可以只声明参数类型
    cout<<fun(10, 5)<<endl; // 15
    return 0;
}
int fun(int a, int b){
    return a+b;
}

Java

和C++的大体上一样，但不支持默认值，也不用声明再调用。
此外，Java是一门高度面向对象的语言，一个函数还要分为访问权限(public、private等)和访问方式(是否是static等)，此处不关注这两个方面。

定义格式

返回值类型 函数名(参数列表)
{
函数主体;

}
其中，返回值类型可以是void(无返回值)，也可以是int、float、vector、bool、string等数据类型；
函数名命名规则和变量一样，参数是可选的

示例1：无参数、无返回

public class JavaCode {
    public static void fun0(){     // static型函数不用实例化，可直接调用
        System.out.println("fun0 runnning!"); // 定义
    }
    public static void main(String[] args){
        fun0();             // 调用
    }
}
// 输出：fun0 runnning!

示例2：有参数、返回一个整型值

public class JavaCode {
    public static int fun1(int x){     // 定义
        return x*x;
    }
    public static void main(String[] args){
        int a = fun1(5);       // 调用
        System.out.println(a); 
    }
}
// 输出：25

示例3：返回多个参数

用Map实现，用key来标识各个返回值，对应的value进行相应的类型转换。

import java.util.HashMap;
import java.util.Map;

public class JavaCode {
    public static Map<String, Object> fun2(int x, String s){
        Map<String, Object> mp = new HashMap<>();   // value用Object，可以存不同类型的数据
        mp.put("res1",x+x);     // 数字*2
        mp.put("res2",s+s);     // 字符串复制一遍
        return mp;
    }
    public static void main(String[] args){
        Map<String, Object> res = fun2(5, "abc");   // 用Map型变量来接收返回值
        int a = (int)res.get("res1");               // 将Object进行类型转换
        String str = (String)res.get("res2");
        System.out.println(a);
        System.out.println(str);
    }
}
/*
输出：
10
abcabc
*/

示例4：参数有默认值

Java不支持参数设置默认值，因为和重载共存的时候会有二义性，如果要实现某个参数有默认值，可以用重载来实现。以下代码fun3函数被重载。

public class JavaCode {
    public static int fun3(int x, int y){   // 传两个参数的时候调用
        return x + y;
    }
    public static int fun3(int x){          // 传一个参数的时候调用
        int y = 100;
        return x + y;
    }
    public static void main(String[] args){
        int a, b;
        a = fun3(5);
        b = fun3(5,10);
        System.out.println(a);  // 105
        System.out.println(b);  // 15
    }
}

示例5：定义在调用之后

Java源代码中函数定义和调用顺序不影响，比如以下两种情况都是可以的。

public class JavaCode {
    public static void fun4(){  // 定义
        System.out.println("fun4 running!"); 
    }
    public static void main(String[] args){
        fun4();  // 调用
    }
}

public class JavaCode {
    public static void main(String[] args){
        fun4();  // 调用
    }
    public static void fun4(){  // 定义
        System.out.println("fun4 running!"); 
    }
}

Python

定义格式

def 函数名(参数列表) -> 返回值类型:
函数主体
其中，返回值类型可以是None(无返回值)，也可以是int、float、string、list等数据类型；
函数名命名规则和变量一样，参数是可选的

示例1：无参数、无返回

def fun0() -> None: # 定义
    print("fun0 running!")

fun0()  # 调用
# 输出：fun0 running!

也可以不指定返回值，解释器自动处理

def fun0():
    print("fun0 running!")

示例2：返回一个值

def fun1(a: int) -> int: # 定义，参数指定类型
    sqr = a**2
    return sqr          # 返回传入参数的平方

b = fun1(5)  # 调用
print(b)
# 输出：25

也可以不指定参数类型

def fun1(a):
    sqr = a**2
    return sqr

示例3：返回多个参数

直接用逗号隔开，可以返回多个参数，参数可以是不同类型
调用的时候用多个变量来接收返回值

def fun2(x):
    x2 = x*2
    x3 = x*3
    return x2,x3    # 返回参数的2倍和3倍

a = 5
a2, a3 = fun2(a)    # 调用，用两个变量来接收返回值
print(a2,a3)
# 输出：10 15

示例4：参数有默认值

def fun3(x, y=100): # 第二个参数默认100
    return x+y

print(fun3(5))      # 传入一个参数，第二个参数用默认值，输出：105
print(fun3(5,10))   # 传入两个参数，两个参数都用传入值，输出：15

示例5：定义在调用之后

python是解释型语言，不支持像C++一样的先声明再定义，以下程序会报错：
NameError: name ‘fun4’ is not defined

fun4()          # 先调用

def fun4():     # 再定义
    print("fun4 running!")

正确地顺序是先定义再调用：

def fun4():     # 先定义
    print("fun4 running!")

fun4()          # 再调用
# 输出：fun4 running!

示例6：两种传参方式

Python既可以直接传参，也可以用形参的名字来传参

def fun(x,y):       
    return x+100*y
print(fun(y=5,x=1)) # 用形参名来传参可以不按顺序
print(fun(1,5))     # 直接传参则是按顺序赋值
# 两次调用均输出：501