函数

【1】函数是什么？

本质：函数是工具

作用：一个函数为了实现一种功能

发展历程：一个函数是为了实现一种客观的需求功能而设计的一种对应工具

通俗一点说，函数其实就是一种工具。程序其实也很简单的，别被哪些老师【专门忽悠学生的人】把你吓着了。

函数是一个功能体。那么，既然是一个功能体，就从现实中的某个例子开始分析一下：什么是函数？即就是，什么是功能体？

比如：一台豆浆机，插上电它就可以运作，那么电资源就是它的运作条件，如同函数必须要放在main()函数内部调用是一样一样的！

如果不插电，也就是说单个功能分析，可以想象一下，豆浆机它要制造豆浆，制造豆浆肯定要有原材料，对不？那什么是它的原材料呢？

好，你可能很清楚，需要豆子。是的，豆子是一类粮食，对吗？OK? Do you understand? 函数的参数，实质上就是这个功能体所需的资源。

只不过模拟现实，各自有了虚拟意义上赋予的类型，现实中人们不在意这样的概念而已。

好，再接着分析，豆浆机把豆子放进去，然后插上电，再打开电源，开始磨豆浆。

过几分钟【其实这就是进程的经典概念】后，关掉电源，打开豆浆机，倒出来的就是你梦寐以求的豆浆。

这样子就好理解了，哦！那也就是说，函数的返回值就是所谓的这个功能体的功能实现的结果！

OK！这样子我们就很简单的把函数这个编程的基本概念元素完全给征服了！

好吧，那么既然这样子的话，我们下面再继续理解专业领域的函数：

int add(int a, int b)
{
    return a + b;
}

这是一个函数，那么，它就是一个功能体，好，它实现怎样的功能呢？对了，一目了然，只有一行代码，实现两个int类型的数据相加的运算，返回值类型仍然是int。

这就达到了绝对的统一。

函数这个东西很神奇的。怎么说呢？

就像人一样的。人也是一个功能体，你吃进去什么类型的都有，然而最后排出来的却是一种类型的（呵呵，这个例子不雅观，但是很说明问题！）。

函数也是这样子的。参数可以有很多种类型，但是最后的结果只有一种类型。

【2】函数有哪几种返回形式？

答案：一般为引用返回，指针返回，值返回。下面就函数返回类型举例如下：

（1）引用返回

<1> 示例1代码如下：

#include <iostream>
using namespace std;

int & fun()
{
    static int a = 10;
    return a;
}

int main()
{
    int x = fun();                  // 以int类型接受
    cout << "x = " << x << endl;    // x = 10
    int &y = fun();                 // 以引用类型接受
    cout << "y = " << y << endl;    // y = 10
    fun() = 100;                    // 引用返回时，这里是可以修改函数值的
    int &s = fun();
    cout << "s = " << s << endl;    // s = 100
    int b = 0;
    b = fun();
    cout << "b = " << b << endl;    // b = 100
    b = ++fun();                    // 引用返回时，这里是可以修改的
    cout << "b = " << b << endl;    // b = 101
    b = 120;                        // 引用返回时，这里也是可以修改的
    cout << "b = " << b << endl;    // b = 120

    system("pause");
    return 0;
}

/* out:
x = 10
y = 10
s = 100
b = 100
b = 101
b = 120
*/

<2> 示例2代码如下：

#include <iostream>
using namespace std;

class Test
{
public:
    Test(int x = 0) : value(x)
    {
        cout << "Create Test : " << endl;
    }
    ~Test()
    {
        cout << "Destroy Test : " << endl;
    }

public:
    int & GetRef()
    {// Test * const this
        cout << ":: GetRef" << endl;
        return value;
    }
    const int & GetRef() const
    {// const Test * const this;
        cout << ":: const GetRef" << endl;
        return value;
    }

private:
    int value;
};

int main()
{
    Test t1(10);
    const Test t2(20);

    int a1 = t1.GetRef();
    int &b1 = t1.GetRef();
    const int &c1 = t1.GetRef();

    int a2 = t2.GetRef();
//  int &b2 = t2.GetRef();  // error!!!cannot convert from 'const int' to 'int &'
    const int &c2 = t2.GetRef();

    return 0;
}

/*
Create Test :
Create Test :
:: GetRef
:: GetRef
:: GetRef
:: const GetRef
:: const GetRef
Destroy Test :
Destroy Test :
*/

（2）指针返回

<1> 示例1代码如下：

#include <iostream>
using namespace std;

int* fun()
{
    static int *p = new int(10);
    cout << "p :: " << p << endl;
    return p;
}

int main()
{
    int *s = NULL;
    s = fun();              // 意味着是S，P指向了同一个内存
    cout << "s :: " << s << endl;
    cout << "*s :: " << *s << endl;
    s = new  int(100);     // s指针另外指向了一个内存
//  fun() = new int(100);    // 这种情况是不可以直接赋值的

    return 0;
}

/*
p :: 0323A3F8
s :: 0323A3F8
*s :: 10
*/

<2> 示例2代码如下：

#include <iostream>
using namespace std;

class Test
{
public:
    Test(int x = 0) : value(x)
    {
        cout << "Create Test : " << endl;
    }
    ~Test()
    {
        cout << "Destroy Test : " << endl;
    }

public:
    int *GetPtr()
    {
        cout << ":: GetRef" << endl;
        return &value;
    }
    const int * GetPtr() const
    {
        cout << ":: const GetRef" << endl;
        return &value;
    }

private:
    int value;
};

int main()
{
    Test t1(10);
    const Test t2(20);

    int *a1 = t1.GetPtr();
    int * const &b1 = t1.GetPtr();
    const int * const &c1 = t1.GetPtr();

    const int *a2 = t2.GetPtr();
    const int * const &b2 = t2.GetPtr();
    const int * const &c2 = t2.GetPtr();

    return 0;
}

/*
Create Test :
Create Test :
:: GetRef
:: GetRef
:: GetRef
:: const GetRef
:: const GetRef
:: const GetRef
Destroy Test :
Destroy Test :
*/

（3）值返回

示例代码如下：

#include <iostream>
using namespace std;

class Test
{
public:
    Test(int x = 0) : value(x)
    {
        cout << "Create Test : " << endl;
    }
    ~Test()
    {
        cout << "Destroy Test : " << endl;
    }

public:
    int GetValue()
    {// Test * const this;
        cout << ":: GetValue" << endl;
        return value;
    }
    int GetValue() const
    {// const Test * const this;
        cout << ":: const GetValue" << endl;
        return value;
    }

private:
    int value;
};

int main()
{
    Test t1(10);
    const Test t2(20);           // 常对象(意味着只可以调用常方法)

    int a1 = t1.GetValue();
    cout << a1 << endl;
//  int &b1 = t1.GetValue();     // error!!!引用必须是一个具体的已存在的同类对象
    // 等价于 
//  int &b1 = 10;                // error!!! cannot convert from 'int' to 'int &'   
    const int &c1 = t1.GetValue();
    // 等价于
    // const int &c1 = 10;
    cout << c1 << endl;

    int a2 = t2.GetValue();
    cout << a2 << endl;
//  int &b2 = t2.GetValue();     // error!!! 原因同上
    const int &c2 = t2.GetValue();
    cout << c2 << endl;

    return 0;
}

/*
Create Test :
Create Test :
:: GetValue
10
:: GetValue
10
:: const GetValue
20
:: const GetValue
20
Destroy Test :
Destroy Test :
*/

（4）指针引用返回

示例代码如下：

#include <iostream>
using namespace std;

int * const & fun()
{
    static int *p = new int(10);   // 静态指针
    return p;
}

int main()
{
    int *s = NULL;
    s = fun();               // 返回值必须赋予指针类型变量
    s = new int(10);
    int * const &r = fun();   // 如果是指针引用，必须为常引用
//  r = new int(10);          // 此时，因为是常引用所以不可修改
//  fun() = new int(100);     // 因为是常引用指针类型所以不可直接修改

    return 0;
}

【3】函数类型如何分析？

让我们来看下面一段代码：

#include <iostream>
using namespace std;

typedef int Func(int, int);  // 定义函数类型; 类型名为Func

int add(int a, int b)
{
    return (a + b);
}

int max(int a, int b)
{
    return (a > b ? a : b);
}

void press(int x, int y, Func c)  // 注意：c为一个函数变量
{
    int z = c(x, y);
    cout << z << endl;
}

int main()
{
    press(12, 23, add);  // 实参为函数名add
    press(23, 34, max);  // 实参为函数名max

    return 0;
}

/*
35
34
*/

如上，关于typedef不懂的可以参考随笔《typedef关键字》

【4】函数指针与函数类型如何区别？

示例代码如下：

#include <iostream>
using namespace std;

int max(int a, int b)
{
    return (a > b ? a : b);
}
int add(int a, int b)
{
    return (a + b);
}

typedef int(*pFun)(int, int);   // 函数指针类型定义
typedef int PFUN(int, int);     // 函数类型定义

void press(pFun a, PFUN b)      // Question1 : ?为什么作为函数参数声明时成立？
{
    cout << a(12, 23) << endl;
    cout << b(12, 23) << endl;
}

int main()
{
    pFun a = add;
//  PFUN c = add;   // syntax error!!! Question2 : ?为什么在定义时不可以？
//  void va;        // 注意：PFUN 与 void一样是一种类型名，但是不可以定义变量
    PFUN *b = add;  // PFUN * 即表示函数指针类型
    press(add, max);

    return 0;
}

注意：Question1 和 Question2，即自定义的函数类型名作为函数的形参类型是可以的，但是作为变量的类型是不允许的。为什么呢？

有一个词，一直以来，尤其特别相当推崇，即自洽，能自圆其说的意思。

仔细观察上例第24行：函数名直接赋值于函数指针。

再看、再看、再看第25行：函数名直接赋值于函数类型。

反证法：如果25行能通过语法预编译，那么pFun类型与PFUN *类型有什么区别呢？该如何区分呢？

这样子想一想，Question1 与 Quention2 的疑惑应该迎刃而解了。

【5】关于函数指针数组注意事项？

示例代码如下：

#include <iostream>
using namespace std;

typedef int(*pFun)(int, int);     // 函数指针类型定义；类型名为pFun

typedef int ARRAY[5];             // 数组类型定义; 类型名为ARRAY

int max(int a, int b)
{
    return (a > b ? a : b);
}

int add(int a, int b)
{
    return (a + b);
}

int main()
{
    ARRAY a, b;  // 定义两个数组a 和 b
    pFun  c;     // 定义函数指针c

    int (*d)(int, int);  // 声明函数指针d

    pFun pf[2] = {add, max};   // 初始化函数指针数组

    pFun(*p)[2] = &pf;         // 初始化函数指针数组指针

    int(*pfun[2])(int, int) = {add, max};  // 定义函数指针数组并初始化
    int(*(*s)[2])(int, int) = &pfun;       // 定义函数指针数组的指针并初始化

    return 0;
}

【6】函数参数的调参顺序如何？

请看如下示例代码，用心观察，总结结论。

示例代码如下：

include <iostream>
using namespace std;

void Fun(int a, int b = 0, int c = 0, int d = 0)
{
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
}

int main()
{
    cout << "Fun(12)" << endl;
    Fun(12);
    cout << "Fun(12, 23)" << endl;
    Fun(12, 23);
    cout << "Fun(12, 23, 34)" << endl;
    Fun(12, 23, 34);

    return 0;
}

/*
Fun(12)
a = 12
b = 0
c = 0
d = 0
Fun(12, 23)
a = 12
b = 23
c = 0
d = 0
Fun(12, 23, 34)
a = 12
b = 23
c = 34
d = 0
*/

当函数参数有默认值时，实参与形参的对应关系如上。可以参见随笔《为什么C++函数形参默认值从最末一个赋值？》

【7】如何实现一个不定形参函数？

示例代码如下：

#include <iostream>
using namespace std;

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
//  4 + 4 - 1=7                   //4-1=3
//  0111                          //~0011=1100
//0111&1100=0100   =4   
#define va_start(ap,v)  ( ap = (va_list)&v + _INTSIZEOF(v) )
//指针= （char*）&V(数值个数)  +  4   
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
//(*(int *)((指针ap += INTSIZEOF(int))-INTSIZEOF(int)))
//*(int *) ((ap=ap+INTSIZEOF(int))-INTSIZEOF(int))
//*(int *)(本段代码执行结果ap向前走4个字节，但是地址不变)
#define va_end(ap)      ( ap = (va_list)0 )
//ap=(char *)0

int average(int n_values, ...)
{
    int sum = 0;

    va_list  var_arg;  //char *

    va_start(var_arg, n_values);

    for (int i = 0; i < n_values; ++i)
    {
        sum += va_arg(var_arg, int);
    }

    va_end(var_arg);
    return (sum / n_values);
}

int main()
{
    cout << average(4, 10, 20, 30, 40) << endl;   //(10 + 20 + 30 + 40) / 4 = 25

    return 0;
}

/*
25
*/

希望有所收获，仅此而已。

 

Good Good Study，Day Day Up.

顺序 选择 循环 总结