函数参数

• 类似于局部变量，函数的形参为函数提供了已命名的局部存储空间
• 函数不能返回另一个函数或者内置数组类型，但可以返回指向函数的指针，或指向数组元素的指针的指针
• 每次调用函数时，都会重新创建该函数所有的形参，此时所传递的实参将会初始化对应的形参。
  形参的初始化与变量的初始化一样：如果形参具有非引用类型，则复制实参的值，如果形参为引用类型（第 2.5 节），则它只是实参的别名
  
• 在 C 语言中，具有 const 形参或非 const 形参的函数并无区别
  
• 复制庞大而复杂的值有昂贵的开销，为了避免传递副本的开销，可将形参指定为引用类型
• 利用 const 引用避免复制
• 应该将不修改相应实参的形参定义为 const 引用，如果将这样的形参定义为非 const 引用，则毫无必要地限制了该函数的使用（const变量不能作为参数传给非cosnt引用的形参）
  

  string func(const string &s)
  {
      return s;
  }
  int main()
  {
      cout << func("ddd");
      return 0;
  }

  如果将func形参定义为非const，则字符串常量不能作为实参传入

• 传递指向指针的引用

  int *&v1
  //v1 是一个引用，与指向 int 型对象的指针相关联

• 通常，函数不应该有 vector 或其他标准库容器类型的形参。调用含有普通的非引用 vector 形参的函数将会复制 vector 的每一个元素 。从避免复制 vector 的角度出发，应考虑将形参声明为引用类型。然而，看过第十一章后我们会知道，事实上，C++ 程序员倾向于通过传递指向容器中需要处理的元素的迭代器来传递容器
  

  #include <iostream>
  #include <vector>
  using namespace std;
  void print_(vector<int>::iterator it1, vector<int>::iterator it2)
  {
      for(vector<int>::iterator it = it1; it != it2; ++it)
      {
          cout << *it << ' ';
      }
      cout << endl;
  }
  int main()
  {
      vector<int> v(10);
      print_(v.begin(), v.end());
      return 0;
  }

  

• 数组形参

  // three equivalent definitions of printValues
  void printValues(int*) { /* ... */ }
  void printValues(int[]) { /* ... */ }
  void printValues(int[10]) { /* ... */ } //编译器忽略为任何数组形参指定的长度。

  当编译器检查数组形参关联的实参时，（非引用传参情况下）它只会检查实参是不是指针、指针的类型和数组元素的类型时是否匹配，而不会检查数组的长度
  
• 不需要修改数组形参的元素时，函数应该将形参定义为指向 const 对象的指针
  
• 通过引用传递数组
  如果形参是数组的引用，编译器不会将数组实参转化为指针，而是传递数组的引用本身。在这种情况下，数组大小成为形参和实参类型的一部分。 编译器检查数组的实参的大小与形参的大小是否匹配
• 只严格地接受含有 10 个 int 型数值的数组
  

  #include <iostream>
  #include <vector>
  using namespace std;
  void print_(int (&a)[10]) //&arr 两边的圆括号是必需的，因为下标操作符具有更高的优先 
  {
      for(int i = 0; i<10; ++i)
          cout << a[i] << ' ';
      cout << endl;
  }
  int main()
  {
      int a[10]{0};
      print_(a);
      print_(a);
      return 0;
  }
  //把a大小改为11时，不能通过编译

• 多维数组的传递
  

  #include <iostream>
  #include <vector>
  using namespace std;
  void print_(int (*a)[10])// void print_(int a[][10]), 
  {
      for(int i = 0; i<2; ++i)
          for(int j = 0; j<10; ++j)
              cout << a[i][j] <<endl;
  }
  int main()
  {
      int a[10][10]={};
      a[0][7] = 32;
      print_(a);
      return 0;
  }

  

• 可以通过传递指向数组第一个和最后一个元素的下一个位置的指针来传参

• // const int ia[] is equivalent to const int* ia
  // size is passed explicitly and used to control access to elements of ia
  #include <iostream>
  using namespace std;
  void printValues(const int ia[], size_t size)
  {
  　　　for (size_t i = 0; i != size; ++i) {
       cout << ia[i] << endl;
     }
  }
  int main()
  {
       int j[] = { 0, 1 }; // int array of size 2
       printValues(j, sizeof(j)/sizeof(*j));
       return 0;
  }

• 当函数需要处理数组且函数体不依赖于数组的长度时应使用指针形参，其他情况下应使用引用形参
• main函数参
  

  // const int ia[] is equivalent to const int* ia
  // size is passed explicitly and used to control access to elements of ia
  #include <iostream>
  using namespace std;
  int main(int argc, char *argv[])
  {
      for(int i=0; i<argc; ++i)//argc表示字符串个数
          cout << argv[i] << endl;
      return 0;
  }

  

• #include <iostream>
  #include <cstdlib>
  using namespace std;
  int main(int argc, char *argv[])
  {
         cout << atoi(argv[1]) + atoi(argv[2]) <<endl;
      return 0;
  }

  
  
  

• 含可变参数的函数