参数传递

形参初始化的机理与变量初始化相同。形参的类型决定了形参和实参的交互方式。

• 引用传递 passed by reference，函数被 传引用调用 called by reference 。形参是引用，绑定到对应实参上。引用形参也是其绑定对象的别名，即引用形参是对应实参的别名。
• 值传递 passed by value ，函数被传值调用 called by value ，将实参的值拷贝赋给形参。

传值参数

初始化非引用类型的变量，传值会拷贝初值，因此对变量的改动不会影响初始值。（对比于python）

指针形参

当执行指针拷贝操作，拷贝的是指针值，即地址值。拷贝后两个指针是不同的指针。通过指针可以修改它所指对象的值，

指针形参的行为类似指针行为，可以改变实参的值，例如下：

void reset(int* ip){
    *ip = 0;  // ip所指对象置 0
    ip = nullptr；  // 改变ip本身的局部拷贝，不改变实参
}

int main(){
    int i = 42;
    reset(&i);         //由于是指针形参，需要取地址传参。
    cout<<i<<endl;     //i=0
}

建议使用引用类型的形参（C++风格）替代指针类型。

传引用参数

对引用的操作实际上是作用在引用所引的对象上。引用形参类似。通过引用形参可以改变一个或多个实参的值。

void reset(int& i){
    i = 0;
}

int main(){
    int i = 42;
    reset(i);         
    cout<<i<<endl;     //i=0
}

使用引用避免拷贝

对较大类型对象和容器对象以及不支持拷贝的对象，为了性能或者可行性，只能通过引用形参访问该类型的对象。

如比较两个string对象的长度。由于string对象可能非常长不便于拷贝，而又不需要在函数中修改时，可以利用对常量的引用定义形参：

bool isShorter(const string& s1, const string& s2){
    return s1.size()<s2.size();
}

使用引用形参返回额外信息

C++函数只能有一个返回值。若要返回多个且有可能不同类型的值，可以构造一个含有这些值类型的新类，或者直接传入一个引用类型的形参并隐式返回该值。

例如该程序同时统计在字符串中某个字符的首次出现位置索引和总次数，可以编写如下：

string::size_type find_char(const string& s, char c, 
                            string::size_type& occurs){
    auto ret = s.size();
    occurs = 0;
    for(decltype(ret)i=0; i!=s.size(); ++i){
        if (s[i]==c){
            if (ret == s.size()) ret = i;
        ++occurs;
        }
    }
    return ret;
}

int main(){
    string::size_type occ;
    string s = "bcdefghahaha";
    string::size_type r;
    r = find_char(s, 'a', occ);
    cout<<"First sub: "<<r<<";\nTotal occurs: "<<occ;
    return 0;
}

输出：

First sub: 7;
Total occurs: 3

const 形参和实参

仅在用实参初始化形参时形参具有的顶层const会被忽略。因此可以传给其常量和非常量。而只能给底层const的形参传递常量。

因此，虽然C++允许定义同名而拥有不同形参列表的函数，但下述两个定义会被认为是同一个，尽管函数内的形参功能不同：

void a(const int i){}
void a(int a){}

指针或引用形参参与const

具体的底层、顶层及可更改对象和初始化规则一致。

尽量使用常量引用

将函数内不会改变其值的形参定义为常量引用，既可以同时接受const和非const类型的实参，又可以避免不需要的问题。

• 问题1：非底层const引用无法使用字面值初始化。

  void a(string a, int b){}
  void b(const string a, const int b){}
  a("str", 1) //error
  b("str", 1) //correct
  

• 问题2：不同函数嵌套时，若内层有函数是普通引用而无法接受const类的实参，会出错。

数组形参

数组的两个特殊性质对定义和使用作用在数组的函数有影响：

• 不允许拷贝数组（如不可以a=b等）：无法以值传递的方式使用数组参数
• 使用数组时可能会被转化为指针：为函数传递数组时实际上是传递了指向该数组首元素的指针。

因此，下列三个表达式等价，形参类型都是const int*。

void a(const int*);
void a(const int[]);     //本意是作用与数组，实际形参是一个指针。
void a(const int[10]);   //10仅仅是期望的元素，实际不一定。

存在的问题：由于无法拷贝且会转为指针，当确实需要数组作为实参时，开始和结束位置难以确定。

使用标记指定数组长度

管理数组实参的第一种方法：要求数组本身包含一个结束标记。典型示例是c风格字符串（以'\0'结尾）的处理：

void print(const char* cp){
    if (cp)          //指向内容不为空
        while (*cp)  //所指字符不是空字符
            cout<<*cp++; 
}

使用标准库规范

管理数组实参的第二种方法：传递指向数组首元素和尾后元素的指针，注意需要在使用函数前使用std::beg或std::end提前取得这两个指针：

void print(const char* beg, const char* end){
    while (beg!=end)
        cout<<*beg++;
}

显式传递表示数组大小的形参

管理数组实参的第三种方法：定义一个表示数组大小的形参。在旧版本的 C++ 和 C 中常用这种方法。注意该形参的类型是size_t。

数组形参和const

和引用形参一样，尽量将指针形参其定义为const类型避免不必要的问题。

数组引用形参

若将变量定义为数组的引用，可以直接使用。但是注意引用构成的数组（X）-int& arr[10] 和 对数组的引用-int (&arr)[10]。

传递多维数组

一般第一个维度使用指针传递，而操作必不可少的第二个维度，只能传入其含有的元素个数：

void print(int (*matrix)[10], int rowSize){}
// 等价于
void print(int matrix[][10], int rowSize){}

int matrix[][10] 看似是个二维数组的声明，实际上声明了一个指向含有10个整型元素的数组的指针。与 int (*matrix)[10] 一致。

main：处理命令行选项

往main()函数中定义参数以设置运行选项，如将这些命令传递给prog文件中的程序：prog -d -o ofile data0：

int main(int argc, char* argv[]){}

第二个形参argv是一个数组，数组内每项都是char指针；第一个形参表示字符串数量。第二个形参是数组，所以main函数也可以定义为：

int main(int argc, char** argv){}

其中 argv 指向 char*。其内容（数组）或指向的内容（指针）：

argv[0] = "prog"; //程序名
argv[1] = "-d";   //开始参数
argv[2] = "-o";
argv[3] = "ofile";
argv[4] = "data0";
argv[5] = 0;

含有可变形参的函数

常常会无法提前预知向函数传递的实参数量。为了使函数处理未知数量实参，C++11提供两种方法：

• 所有实参类型相同：传递名为 initializer_list 的标准库类型；
• 实参类型不同：可变参数模板

initializer_list 形参

• initializer_list对象中的元素永远是常量值，无法改变。

• 使用begin和end成员可以完成类似vector的迭代器操作。

• 向该类型形参中传递一个值的序列，必须把序列放在一对花括号内：

  initializer_list<string> str = a?  {"A", "B"}:{"C", "D", "E"};
  

• 含有该类型形参的函数也可以含有其他类型的形参

省略符形参

省略符形参是为了便于C++程序访问某些特殊的C代码设置的，这些代码使用了名为varargs的C标准库功能。通常省略符形参不应用于其他目的。

只能出现在形参列表最后一个位置，但注意大多数类类型的对象无法正确拷贝给该形参。