C++笔记（十）函数

//function.cpp 函数

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

/*
函数格式如下：
typename functionName(paramlist){
    statement;
    return value;
}
typename;返回值类型
functionName:函数名称
paramlist:函数的参数列表
statement：函数体
return value:返回值
*/


struct user {
    int age;
};

//函数原型
void simple();
void number(int num);//带参数的函数
void hello(int number, int number1);//多个参数
int total(int arr[],int n);//代返回值的函数
int total2(int * attr, int n);//使用指针
int total3(const int attr[], int n);//使用const保护数组内容。
user addAge(user u1, user u2);//函数中的修改，不会改变原数据
user addAge1(user* u1, user* u2);//函数中的修改，会改变原结构的数据
void teststr(string str);//函数中的修改，不会改变原数据
void testarray(array<int,3> ai);//函数中的修改，不会改变原数据

int main() {
    //调用函数
    simple();

    /*
    c++传递参数是按值传递。下面的函数number在被调用时，会创建一个新的变量num，并初始化为10。相当于重新复制了一个变量。
    所以number函数中执行的操作，并不会影响到main函数中的数据。
    */
    int num = 10;
    number(num);
    cout << "num=" << num << endl;
    hello(100, 200);

    //函数和数组
    int attr[3] = {100,200,300};
    int sum = total(attr, 3);
    cout << "sum=" << sum << endl;
    cout << attr[0] << " " << attr[1] << " " << attr[2] << endl;
    int sum2 = total2(attr, 3);
    cout << "sum=" << sum2 << endl;

    /*
    需要注意的是，传递数组给函数，实际上是传递了数组的地址给函数，函数中修改数组的内容会影响main中的数组内容。
    这并不违背函数的按值传递，只不过重新复制的是数组的地址，而不是数组的内容。
    */

    //使用const保护数组内容
    int sum3 = total3(attr, 3);
    cout << "sum=" << sum3 << endl;


    //const 指针
    int num1 = 100;
    const int* pi1 = &num1;//将常规变量赋值给const指针
    //*pi1 = 5; const 指针不能修改指向的值。
    const int num2 = 100;
    const int* pi2 = &num2;//将const变量赋值给const指针
    const int num3 = 100;
    //int* pi3 = &num3; 不能将const变量赋值给非const指针


    //结构和函数
    user u1 = { 10 };
    user u2 = { 20 };

    user u3 = addAge(u1, u2);//函数中的修改，不会改变u1和u2的值。值传递
    cout << u3.age << endl;
    cout << "u1.age:" << u1.age << "  u2.age:" << u2.age << endl;
    user u4 = addAge1(&u1, &u2);//因为传递的是地址，所以函数中的修改，会改变u1和u2的值。
    cout << u3.age << endl;
    cout << "u1.age:" << u1.age << "  u2.age:" << u2.age << endl;

    string str = "hello";
    teststr(str);
    cout << str << endl;

    array<int, 3> ai = { 10,20,30 };
    testarray(ai);
    cout << ai[0] << endl;

    /*
    函数指针,格式 typename (*pf)(paramtypelist)
    typename:返回类型
    *pf:函数指针
    paramtypelist：参数类型列表
    */
    void (*pf)();
    pf = simple;
    (*pf)();
    pf();

    void(*pf1)(int) = number;
    pf1(10);
    void(*pf2)(int,int) = hello;
    pf2(1, 2);

    int(*pf3)(int[], int) = total;
    int total = pf3(attr,3);
    cout << total << endl;

    int(*pf4)(int*, int) = total2;
    int total1 = pf4(attr, 3);
    cout << total1 << endl;


    return 0;
}


//函数实现
void simple() {
    cout << "function simple()" << endl;
}

void number(int num) {
    num = 100;
    cout << num << endl;
}

void hello(int num,int num1) {
    cout << "num=" << num << " num1=" << num1 << endl;
}

int total(int attr[],int n) {
    int sum = 0;
    for (int i = 0;i < n;i++) {
        sum += attr[i];
        attr[i] = 1000;
    }
    return sum;
}

int total2(int* attr, int n) {
    int* end = attr + n;
    const int* pt; //将const应用于指针，可以防止通过该指针修改指向的值。
    int sum = 0;
    for (pt = attr;pt != end;pt++) {
        sum += *pt;
    }
    return sum;
}

int total3(const int attr[], int n) {
    int sum = 0;
    for (int i = 0;i < n;i++) {
        sum += attr[i];
        //attr[i] = 1000; 常量不能进行修改
    }
    return sum;
}

user addAge(user u1, user u2) {
    user u;
    u.age = u1.age + u2.age;
    u1.age = 100;
    u2.age = 200;
    return u;
}


user addAge1(user* u1, user* u2) {
    user u;
    u.age = u1->age + u2->age;
    u1->age = 100;
    u2->age = 100;
    return u;
}

void teststr(string str) {
    cout << str << endl;
    str = "teststr";
}


void testarray(array<int, 3> ai) {
    ai[0] = 1000;
}

输出结果：

function simple()
100
num=10
num=100 num1=200
sum=600
1000 1000 1000
sum=3000
sum=3000
30
u1.age:10  u2.age:20
30
u1.age:100  u2.age:100
hello
hello
10
function simple()
function simple()
100
num=1 num1=2
3000
3000