函数

为勐腊等地区用户提供了全套网页设计制作服务，及勐腊网站建设行业解决方案。主营业务为网站设计、网站制作、勐腊网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！目录：

• 函数
• • 函数概述
  • 函数类型
  • 函数定于与声明
  • 函数参数
  • 引用
  • 函数可变函数
  • • 函数可变参数 使用
  • 函数默认参数
  • 函数返回值
  • 函数嵌套调用
  • 函数递归
  • 内联函数
  • 内联函数与普通函数区别
  • 函数重载

函数概述

C++语言中的函数在其他编程语言中也称为过程或子例程。 我们可以创建函数来执行任何任务。 一个函数可以调用多次。

函数提供模块化和代码可重用性。

函数有很多优点，但这里主要介绍以下两点：

1. 提高代码可重用性

通过在C++中创建函数，可以调用函数多次。 所以实现相同的功能不需要一遍又一遍地编写 相同的代码。

2. 代码优化

函数能使代码优化，我们不需要写很多代码。假设，要检查多个数字(111,663和781等)是否是 素数。 如果不使用函数，需要编写计算质数逻辑程序3次。 所以，这里就产生了不必要的重 复代码。

函数类型

C++编程语言有两种类型的函数

1. 库函数：是在C++头文件中声明的函数，入：ceil(x)，cos(x)，exp(x)等
2. 用户定义的函数：是由C++程序员创建的函数，以遍可以多次使用它。它降低了大程序的复杂性并优化了代码。

函数定于与声明

定义函数

type funcName(paramlist)
{
    // todo
    return value;
}

声明函数

type funcName(paramlist);

区别：

直接定义函数一般放在main函数之前，定义完即可使用

另外，可以在main函数前先声明，在mian之后定义函数

函数参数

语法

void  funcName(paramType1 param1, paramType2 param2)  

  {  

 	 // 执行语句...  

  } 

定义了一个函数funcName，该返回的返回值类型是 type，如果没 有返回值，则写void。

该函数有两个参数，分别为paramType1类型的参数param1和paramType2类型的参数param2，函数的返回值为void。

引用

引用即为某个已存在的变量取别名，引用变量与被引用变量共用一块内存空间，比如土豆和马铃薯都是同一种东西的不同命名。

通过在数据类型后、变量名前添加“&”符号来定义引用类型。

语法：

type &name=data;

int num = 11;

int &num2 = num; // num2就是num的别名，num2就是num的引用

引用特性

1. 引用只是别名，不占内存；和它引用的变量共用同一块内存空间；
2. 引用仅在定义时带&,使用时普通变量一样使用,不含&;
3. 引用必须在创建的时候初始化，一旦引用初始化后，就不能改变 引用所指向的变量，类似于指针常量。
4. 引用必须与一个确定的合法内存单元相关联,不存在NULL引用且不可以使用；

一个变量可以有多个引用，就像人一样，有可能有多个昵称！

引用使用场景

1. 做参数

   void change (int &v1,int &v2){}

   在函数被调用时，就相当于传递实参

#includeusing namespace std;
void change(int & num)
{
	num *= 2;
}
int main()
{
    int x = 100;
    change(x);
    cout<< "x= "<< x<< endl;
    return 0;
}

2. 引用做返回值

​ 语法

type& funcName(){}

当函数返回一个引用时，则返回一个指向返回值的隐式指针

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返 回一个对局部变量的引用是不合法的，但是，可以返回一个对静态

变量的引用。

int& func(int& v1) {
    v1 *=100;
    return v1;
}
int main() {
    int num = 2;
    cout<< func(num)<< endl;
    cout<< num<< endl;
    return 0;
}

形参与实参

形参：函数括号里面的变量参数，叫形式参数

type funcName(type v1,type v2);

实参：调用函数时给的实值，叫实际参数

funcName(2,3);

函数可变函数

语法

type  funcName(paramType1 param1, ...)  
  {  
      // 执行语句...  
      return value；  
  } 

可变参数，即函数参数的个数是任意的，最典型的可变参数的就是 系统内置的 scanf 函数和 printf 函数。

可变参数的函数必须至少有一个强制参数，可选参数的类型可以变 化。可选参数的数量由强制参数的值决定，或由用来定义可选参数 列表的特殊值决定。

对于每一个强制参数来说，函数头部都会显示一个适当的参数，像 普通函数声明一样。参数列表的格式是强制性参数在前，后面跟着 一个逗号和省略号（…），这个省略号代表可选参数。

可变参数函数要获取可选参数时，必须通过一个类型为 va_list 的对象，它包含了参数信息。这种类型的对象 也称为参数指针（argument pointer），它包含了栈中至少一个参数的位置。

可以使用这个参数指针从一个可选参数移动到下一个可选参数，由此，函数就可以获取所有的可选参数。 va_list 类型被定义在头文件 stdarg.h 中。

当编写支持参数数量可变的函数时，必须用 va_list 类型定义参数指针，以获取可选参数。当我们处理可变参 数时，主要涉及到以下几个宏函数：

va_start

语法

void va_start(va_list argptr, lastparam);

argptr

定义好的va_list变量。

lastparam强制参数。

宏 va_start 使用第一个可选参数的位置来初始化 argptr 参数指针。该宏的第二个参数必须是该函数最后一个有 名称参数的名称。必须先调用该宏，才可以开始使用可选参数

函数可变参数 使用

va_arg

语法

type va_arg(va_list argptr, type);

argptr定义好的 va_list 变量。

type可变参数的具体类型。

展开宏 va_arg 会得到当前 argptr 所引用的可选参数，也会将 argptr 移动到列表中的下一个参数。宏 va_arg 的第二个参数是刚刚被读 入的参数的类型。

va_end

语法

void va_end(va_list argptr);

argptr定义好的 va_list 变量。

当不再需要使用参数指针时，必须调用宏 va_end。如果想使用宏 va_start 或者宏 va_copy 来重新初始化一个之前用过的参数指针， 也必须先调用宏 va_end。

va_copy

语法

void va_copy(va_list dest, va_list src);

dest目的 va_list 变量。

src源 va_list 变量。

宏 va_copy 使用当前的 src 值来初始化参数指针 dest。然后就可以 使用 dest 中的备份获取可选参数列表，从 src 所引用的位置开始。

函数可变参数 案例

用函数可变参数，实现求任意变量的和。

#include#include#includeusing namespace std;
int mulSum(int n, ...)
{int sum = 0;
    va_list argptr;
    va_start(argptr, n);
    for (int i = 0; i< n; i++)
    {// 初始化argptr
        // 对每个可选参数，读取类型为int
        sum += va_arg(argptr, int);    //累加到 sum  中
    }
    va_end(argptr);
    return sum;
}
int main()
{int result = mulSum(4, 1, 3, 5, 8);
    cout<< "result = "<< result<< endl;
    return 0;
}

函数默认参数

定义 函数 时可以给形参指定一个默认的值，这样调用函数时如果 没有给这个形参赋值（没有对应的实参），那么就使用这个默认的 值。也就是说，调用函数时可以省略有默认值的参数。如果用户指 定了参数的值，那么就使用用户指定的值，否则使用参数的默认值。

所谓默认参数，指的是当函数调用中省略了实参时自动使用的一个 值，这个值就是给形参指定的默认值。

语法

type  funcname(paramterType param1, paramterType2 param2 = value)   
  {  	return [val];  
  } 

默认参数案例

#includeusing namespace std;
int sum(int num1, int num2 = 100)
{int ret = num1 + num2;
    cout<< ret<< endl;
}
int main()
{int num1 = 1;
    int num2 = 2;
    sum(num1, num2);
    sum(num1);
    return 0;
}

函数返回值

C++ 中 函数 可以不返回任何值，也可以返回一个值，但 C++ 的函数不支持返回多个值。同时，C++ 函数的返回值需要显式的声明其 类型。

语法

type  funcName(paramType1 param1, paramType2 param2)  
  {  // 执行语句...  
      return value; 
 } 

函数嵌套调用

函数可以嵌套调用，即，我们可以在一个函数里面调用另一个函数。

语法

void funcName()
{funcName1();
    funcName2();
           [return]
}

函数递归

函数递归就是一个 函数在函数体内又调用了自身，称为函数的递 归调用。

语法

type funcName(param)
{
    if (param == cond)
    {
           return;
    }
    funcName(param2);
}

递归条件

1. 执行一个函数时，就创建一个新的受保护的独立空间(新函数栈)。

2. 函数的局部 变量 是独立的，不会相互影响。

3. 递归必须向退出递归的条件逼近，否则就是无限递归了。

4. 当一个函数执行完毕，或者遇到 return，就会返回，遵守谁调用， 就将结果返回给谁，同时当函数执行完毕或者返回时，该函数本身也会被系统销毁。

**递归图示 **

递归案例

求1+2+3+4+5+…+n的和

int sum(int n){int total = 0;
    for(int i=1; i<=n;i++){total += i;
    }
    return toatl;
}

简单算法实现代码

int sum(int n){return （1+n）*n /2.0;
}

递归实现代码

int sum(int n){if(n==1){ return 1;
    }
    return sum(n-1) + n;
}

递归案例2

递归实现斐波那契数列（fibo）的第n项。

int fibo(int n){if(n<= 2){ return 1;
    }
    else{ return fibo(n-1) + fibo(n-2);
    }
}

递归案例3 汉罗塔

移动过程中必须遵守以下规则：

1. 每次只能移动柱子最顶端的一个圆盘；

2. 每个柱子上，小圆盘永远要位于大圆盘之上.

分析：

只有一个盘子

两个盘子

对于 n 个圆盘的汉诺塔问题，移动圆盘的过程是：

1. 将起始柱上的 n-1 个圆盘移动到辅助柱上；
2. 将起始柱上遗留的 1 个圆盘移动到目标柱上；
3. 将辅助柱上的所有圆盘移动到目标柱上。

void hanoi(int num, char sou, char tar,char aux) {static int count = 1;//统计移动次数
	//如果圆盘数量仅有 1  个，则直接从起始柱移动到目标柱
    if (num == 1) {cout<< "第”<//递归调用 hanoi() 函数，将 num-1  个圆盘从起始柱移动到辅助柱上
        hanoi(num - 1, sou, aux, tar);
        //将起始柱上剩余的最后一个大圆盘移动到目标柱上
        cout<< "第”<//以移动 3 个圆盘为例，起始柱、目标柱、辅助柱分别用 A、B、C  表示
    hanoi(3, 'A', 'B', 'C');
    return 0;
}

内联函数

在 C 语言 中，如果一些 函数 被频繁调用，不断地有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。在 C++ 中，为了解决 这个问题，特别的引入了inline修饰符，表示为内联函数。

栈空间就是指放置程式的局部数据也就是函数内数据的内存空间，在系统下，栈空间是有限的，假如频繁大量的使用就会造成因栈空间不足所造成的程式出错的问题，函数的死循环 递归调用 的最终结果就是导致栈内存空间枯竭。

使用场景

函数是一个可以重复使用的代码块，CPU 会一条一条地挨着执行其中的代码。CPU 在执行主调函数代码时如果遇到了被调函数，主调函数就会暂停，CPU 转而执行被调函数的代码；被调函数执行完毕后再返回到主调函数，主调函数 根据刚才的状态继续往下执行。

一个 C/C++ 程序的执行过程可以认为是多个函数之间的相互调用过程，它们形成了一个或简单或复杂的调用链条，这个链条的起点是 main()，终点也是 main()。当 main() 调用完了所有的函数，它会返回一个值（例如 return 0;）来结 束自己的生命，从而结束整个程序。

函数调用是有时间和空间开销的。程序在执行一个函数之前需要做一些准备工作，要将实参、局部变量、返回地址以及若干寄存器都压入栈中，然后才能执行函数体中的代码；函数体中的代码执行完毕后还要清理现场，将之前压入栈中的数据都出栈，才能接着执行函数调用位置以后的代码。

如果函数体代码比较多，需要较长的执行时间，那么函数调用机制占用的时间可以忽略；如果函数只有一两条语句， 那么大部分的时间都会花费在函数调用机制上，这种时间开销就就不容忽视。

为了消除函数调用的时空开销，C++ 提供一种提高效率的方法，即在编译时将函数调用处用函数体替换，类似于 C 语言中的宏展开。这种在函数调用处直接嵌入函数体的函数称为内联函数（Inline Function），又称内嵌函数或者内置函数。

内联函数定义

关键字 inline 必须与函数定义体放在一起才能使函数成为内联，仅将 inline 放在函数声明前面不起任何作用。

语法

inline returntype funcname(paramterType params)   // inline  与函数定义体放在一起
{return [val];
}

技术细节

如下的函数风格，不是内联函数，因为内联函数的 inline 关键字，只能放在函数定义的地方：

inline void Foo(int x, int y); // inline 仅与函数声明放在一起
void Foo(int x, int y)
{}

inline关键字

inline 是一种 “用于实现的关键字”，而不是一种 “用于声明的关键字”。一般地，用户可以阅读函数的声明，但是看不到函数的定义。尽管在大多数教科书中内联函数的声明、定义体前面都加了 inline 关键字，但我认为 inline 不应该出现在函数的声明中。

这个细节虽然不会影响函数的功能，但是体现了高质量 C++/C 程序设计风格的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需要内联

使用限制

inline 的使用是有所限制的，inline 只适合涵数体内代码简单的函数数使用，不能包含复杂的结构控制语句例如 while**、switch 并且内联函数本身不能是直接递归函数(自己内部还调用自己的函数)**

内联函数 案例

判断多个数是否为偶数？

#includeusing namespace std;
inline bool isEven(int num)
{return num % 2 == 0;
}
int main()
{int num1 = 100;
    int num2 = 101;
    bool b1 = isEven(num1);
    bool b2 = isEven(num2);
    cout<< “b1 = “<< b1<http://kswjz.com/article/coihdj.html