定义一个函数

• 函数中的传参是值传递，而不是地址传递，在函数中对参数进行修改，不会影响实参，详见下例 ```cpp

  include

using namespace std;

int sum(int num1,int num2){ num1 = num1 + 1; return num1 + num2; }

int main() { int num1 = 12; cout << sum(num1, 13) << endl; cout << num1 << endl;

return 0;

}

> 26
> 12
<a name="sSXbL"></a>
### 函数的声明
一般来说，函数在调用之前必须已经被声明，比如以下代码无法正常运行，主要就是sum这个方面没有在main方法执行之前被声明。
```cpp
#include <iostream>
using namespace std;
int main()
{
    cout << sum(1, 2) << endl;
    return 0;
}
int sum(int num1,int num2){
    return num1 + num2;
}

error: ‘sum’ was not declared in this scope

方案一：

#include <iostream>
using namespace std;
//将要调用的方法移动到main方法之前
int sum(int num1,int num2){
    return num1 + num2;
}
int main()
{
    cout << sum(1, 2) << endl;
    return 0;
}

方案二：

#include <iostream>
using namespace std;
int sum(int num1, int num2);//先向编译器声明该方法
int main()
{
    cout << sum(1, 2) << endl;
    return 0;
}
int sum(int num1,int num2){
    return num1 + num2;
}

头文件

当项目的规模变大以后，我们就开始考虑解耦，比如上边的sum方法我们将他独立出去，这时候就用到了头文件，即以.h为后缀名的文件

• sum.h ```cpp

  include

  using namespace std;

int sum(int num1, int num2);

注：头文件中仅声明方法，但并不定义（当然也可以直接在这里定义，舍弃sum.cpp）
- sum.cpp
```cpp
# include "sum.h"
int sum(int num1,int num2){
    return num1 + num2;
}

• main ```java

  include

  include “sum.h”

using namespace std;

int main() { cout << sum(1, 2) << endl; return 0; }

注：在VSCode中，编译器可能无法将sum.h和sum.cpp关联起来，我们也可以把main文件里的sum.h修改为sum.cpp就可以正常运行了。
<a name="BGKQQ"></a>
### 
<a name="CtF8T"></a>
### 指针传递、值传递，引用传递
<a name="ReGeK"></a>
#### 值传递
```c
#include <iostream>
using namespace std;
int sum(int num1,int num2){
    return num1 + num2;
}
int main()
{
    cout << sum(1, 2) << endl;
    return 0;
}

值传递的作用在于拷贝一份变量然后传给函数，在函数中进行修改并不会对实参造成影响，但拷贝本身不如指针/引用传递高效，一般C++推荐用常量引用替代值传递,一般方面调用语法不如指针复杂，效率和指针一样高：

常量引用替代值传递

#include <iostream>
using namespace std;
int sum(const int& num1,const int& num2){
    return num1 + num2;
}
int main()
{
    cout << sum(1, 2) << endl;
    return 0;
}

指针传递

#include <iostream>
using namespace std;
void add(int* num1){
    *num1 = *num1+1;
    return;
}
int main()
{
    int num = 20;
    add(&num);
    cout << num << endl;
    return 0;
}

引用替代指针传递

#include <iostream>
using namespace std;
void add(int& num1){
    num1++;
    return;
}
int main()
{
    int num = 20;
    add(num);
    cout << num << endl;
    return 0;
}

注：可以看到语法相对简单了很多，不用重复做取值/取地址的操作

常函数

在函数上加上const关键字，可以将该函数设置为常函数，常函数的特点是该函数内不能修改除了mutable以外的任何变量。

#include <iostream>
#include <string>
using namespace std;
class People{
    private:
        mutable int age;
        string name;
    public:
        People(string name,int age){
            this->age = age;//this是一个指针，代表当前的对象
        }
        /**
         * println()函数加上const，所以是常函数，不能修改非mutable的参数，否则编译器会报错
         **/
        void println() const{
            age = 30;//age加上了mutable属性所以可以修改,但如果想改name，会无法编译
            cout <<"姓名：" <<name<< "年龄：" << age << endl;
        }
};
int main()
{
    People p("小明", 20);
    p.println();
    return 0;
}