C++ 基础与深度分析 Chapter6 函数（函数基础、函数详解-参数、函数体、返回类型）

函数基础

int Add(int x, int y) // 形参 // 函数头
{
    return x + y; // 函数体
}

int main()
{
    cout << Add(2, 3) << endl; // 实参 函数调用
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;
#include "header.h"

int Add(int x, int y); // 函数的声明，一个或多个，一般放在header文件中
int Add(int x, int y); // 函数的声明，一个或多个，一般放在header文件中

int main()
{
    cout << Add(2, 3) << endl; // 实参 函数调用
}

int Add(int x, int y) // 函数的定义
{
    return x + y; 
}

// x = 2
// y = 3
// 拷贝初始化
int Add(int x, int y) // 函数的定义
{
    return x + y; 
}

int main()
{
    cout << Add(2, 3) << endl; // 实参 函数调用
}

函数调用栈：


c语言不支持函数的重载，cpp支持。

// c语言形式的函数
extern "C"
int Add(int x, int y) // 函数的定义
{
    return x + y; 
}

// c语言形式的函数，不支持2个C语言的同名函数，因为不支持c语言不支持函数重载
extern "C"
int Add(int x) 
{
    return x + 1; 
}

int main()
{
    cout << Add(2, 3) << endl; // 实参 函数调用
}

函数参数

void fun(int x, int y)
{

}

void fun(int z, int y) // 形参名称的不同，并不能引入函数的重载
{
    
}

int main()
{
    cout << fun(2, 3) << endl;
}

void fun(int x, int y)
{
    cout << x + y << endl;
}


int main()
{
    fun(2, 3); // 2初始化x，3初始化y，顺序不定
}

传值

void fun(int par)
{
    ++par;
 }

int main()
{
    int arg = 3;
    fun(arg); 
    cout << arg; // 3 arg不会改变，我们只是把arg的值传给了par。
}

传址

void fun(int* par) // par是指针
{
    ++(*par);
 }

int main()
{
    int arg = 3;
    fun(&arg); 
    cout << arg; // 4 把arg的地址传给par
}

传引用

void fun(int& par)
{
    ++par;
 }

int main()
{
    int arg = 3;
    fun(arg); 
    cout << arg; // 4 传引用，par被绑定到了arg上，所以par的修改，影响arg
}

参数类型退化

void fun(int* par)
{
}

int main()
{
    int a[3];
    fun(a); // a拷贝初始化par，a退化成指向第一个元素的指针
}

为了防止类型退化，使用引用

变长参数
initializer_list：传入的类型必须是相同的，不涉及元素的拷贝，只是指针的拷贝。

#include <iostream>
#include <initializer_list>
using namespace std;

void fun(std::initializer_list<int> par) // 都必须是int类型的参数
{

}

int main()
{
    fun({1, 2, 3, 4, 5});
}

可变长度模版参数
后面讨论模版再详谈。

使用省略号

printf就是省略号实现的，他是c语言的，cpp中不建议用省略号，建议用initializer_list。

缺省实参：

void fun(int x = 0)
{
    cout << x << endl;
}

int main()
{
    fun(); //  0 缺省的实惨
    fun(1); // 1 
}

如果一个函数前面的参数定义了默认值，那么后面的参数也必须定义缺省值。否则不合法。


实参会按照从左到右，匹配形参。




缺省实参为对象时，实参的缺省值会随着对象变化。

int x = 4;
void fun(int y = x)
{
    cout << y << endl;
}

int main()
{
    fun(); // 随着x的变化而变化
}

一般情况下，不要这么写，还是老老实实写函数的定义。不传对象。

main函数



可以通过这个方法给main传递相应的参数。

函数函数体

void fun()
{
    cout << "Hello" << endl;
}

int main()
{
    fun(); // fun函数隐式返回，因为void
}

int fun()
{
    cout << "Hello" << endl;
}

int main()
{
    fun(); // warning: non-void function does not return a value [-Wreturn-type]
}

main函数的隐式返回是0.
除了main，其他所有函数，如果想使用隐式返回，必须写void。

显示返回，必须要写return返回。

void fun()
{
    cout << "Hello" << endl;
    return; // 显示返回，不会到}去隐式返回了
}

int main()
{
    fun();
}

int fun()
{
    cout << "Hello" << endl;
    return 100; 
}

int main()
{
    int x = fun();
    cout << x << endl; // 100，上面fun函数的返回值
}

return初始化列表：

std::vector<int> fun()
{
    cout << "Hello" << endl;
    return {1, 2, 3, 4, 5}; 
}

int main()
{
    auto x = fun();
    for (auto i : x)
    {
        cout << i << endl; // 1 2 3 4 5
    }
}

小心返回自动对象的引用和指针



返回值优化RVO：return value optimization
c++17引入的优化机制，是针对返回临时对象的。

函数返回类型

返回类型表明了函数计算结构的类型

int fun(int x, int y)
{
    return a + b; // 返回类型时int
}
int main()
{
   
}

void

void fun(int x = 1, int y = 2)
{
    cout << x << ' ' << y << endl;
    return; // 不返回任何类型
}

int main()
{
   fun();
}

上述都为经典方法，位于函数头部

C++11开始，位于函数尾部

auto fun(int x = 1, int y = 2) -> int
{
    return x + y;
}

自动推导



constexpr if 构造“具有不同返回类型”的函数

返回类型的结构化绑定
C++17

[[nodiscard]]属性