C++ 函数

定义函数

#include <iostream>

void test1(int number);

int main() {
    int a = 100;

    test1(a);

    return 0;
}

void test1(int number) {
    std::cout << "this is test1(). " << number << std::endl;
}

数组作为参数

是将数组的第一个元素的地址传递过去，并不是将数组内容传递给函数。

#include <iostream>

void test1(int num[], int n);

int main() {
    int a[3] = {1, 21, 56};

    test1(a, 3);

    return 0;
}

void test1(int num[], int n) {
    for (int i = 0; i < 3; ++i) {
        std::cout << num[i] << std::endl;
    }
}

可变参数

#include <iostream>
#include <stdarg.h> // 可变参数支持

void sum(int count, ...){
    va_list vp;  // 可变参数的动作
    va_start(vp, count);

    int number1 = va_arg(vp, int);
    std::cout <<  number1 << std::endl;

    int number2 = va_arg(vp, int);
    std::cout <<  number2 << std::endl;

    va_end(vp);
}

int main() {
    sum(999, 10, 21, 32, 41, 5, 62);

    return 0;
}
// 打印结果：
//10
//21

1）for 遍历

#include <iostream>
#include <stdarg.h> // 可变参数支持

void sum(int count, ...){
    va_list vp;  // 可变参数的动作
    va_start(vp, count);

    for (int i = 0; i < count; ++i) {
        std::cout <<  va_arg(vp, int) << std::endl;
    }

    va_end(vp);
}

int main() {
    sum(6, 10, 21, 32, 41, 5, 62);

    return 0;
}

函数特殊写法

#include <iostream>

// int 和 double 可用于以后扩展
void MyTest(char * text, int, double ){
    std::cout << text << std::endl;
}

int main() {
    MyTest("hello", 1, 2.0);
    
    return 0;
}

默认参数

#include <iostream>

void test1(int number1, int number2 = 10) {
    std::cout << number1 * number2 << std::endl;
}
int main() {
    int a = 100;
    test1(a); // 1000

    int b = 200;
    test1(a, b); // 20000

    return 0;
}

预定义函数 / 内置函数

#include <iostream>
#include <algorithm>

int main() {
    std::plus<int> add_fun;
    int res1 = add_fun(1, 2);
    std::cout << res1 << std::endl;

    std::minus<float> minus_fun;
    float res2 = minus_fun(2.1F, 11.23);
    std::cout << res2 << std::endl;

    std::multiplies<int> multiplies_fun;
    int res3 = multiplies_fun(23, 3);
    std::cout << res3 << std::endl;

    return 0;
}

函数指针

函数也有地址，函数的地址是存储其机器语言代码的开始地址。例如，可以编写将另一个函数的地址作为参数的函数，这样第一个函数将能够找到第二个函数，并运行它；与直接调用另一个函数相比，这种方法笨拙，但它允许再不同的时间传递不同的函数地址。

#include <iostream>

int test1(int n) {
    return n * 10;
}

int test2(int n) {
    return n * 100;
}

void test3(int number, int (*pf)(int)) {
    std::cout << (*pf)(number) << std::endl;
}

int main() {
    test3(10, test1);
    test3(20, test2);
    
    return 0;
}
// result:
// 100
// 2000

引用变量

创建引用变量

& 既可以用来表示变量的地址，也可以用来声明引用。

将number2 作为number1 变量的别名：
它们指向的是相同的值和内存单元。

#include <iostream>

int main() {
    int number1 = 10;
    int & number2 = number1;

    std::cout << number1 << ", " << &number1 << std::endl; // 10, 0xffffcc34
    std::cout << number2 << ", " << &number2 << std::endl; // 10, 0xffffcc34

    return 0;
}

引用用于函数参数

case1

这种交换变量的方式，并不能改变number1 和 number2的值。
变量a和b相当于复制了number1和 number2的值的新变量，因此交换a和b，并不影响number1和 number2的值。

#include <iostream>

void swap1(int a, int b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

int main() {
    int number1 = 10;
    int number2 = 50;

    swap1(number1, number2);
    std::cout << number1 << ", " << number2 << std::endl; // 10, 50
    
    return 0;
}

case2 指针方式

指针方式，能修改number1 和 number2的值。

#include <iostream>

void swap2(int * a, int * b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int number1 = 10;
    int number2 = 50;

    swap2(&number1, &number2);
    std::cout << number1 << ", " << number2 << std::endl; // 50, 10

    return 0;
}

case3 引用方式

a和b相当于number1和number2的别名，交换a和b的值，相当于交换number1和number2的值。

#include <iostream>

void swap3(int &a, int &b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
}

int main() {
    int number1 = 10;
    int number2 = 50;

    swap3(number1, number2);
    std::cout << number1 << ", " << number2 << std::endl; // 50, 10

    return 0;
}

引用用于结构

#include <iostream>

struct show1 {
    std::string name;
    int age;
};

void test1(show1 & s) {
    std::cout << s.name << ", " << s.age << std::endl; // zhangSan, 23
}

int main() {
    show1 one = {"zhangSan", 23};

    test1(one);

    return 0;
}

常量引用

常量引用，无法修改，只读

#include <iostream>

// 常量引用，无法修改，只读
void get(const int & a) {
//    a = a + 10;  // 不允许修改
    std::cout << a << std::endl;
}

int main() {
    int number = 10;
    get(number);
    
    return 0;
}

函数重载

C不支持，C++支持

#include <iostream>

// 默认值
void change(bool isOK = 0) {
    std::cout << isOK << std::endl;
}

void change(int a){
    std::cout << a << std::endl;
}

void change(int a, int b){
    std::cout << a << ", " << b << std::endl;
}

int main() {
    change();

    change(1);

    change(1,2);

    return 0;
}

函数模板（似java泛型）

#include <iostream>

template <typename  T>

void addAction(T number1, T number2) {
    std::cout << number1 + number2 << std::endl;
}

int main() {
    addAction(1, 2);
    addAction(1.1f, 2.1f);
    addAction(1.2, 1.3);
    
    return 0;
}