C++学习笔记--函数

a.函数是具有用途的自包含的代码块。函数名既是函数的标识，用来在程序中调用函数。如果函数名不在名称空间中定义，它就是全局的，否则就要用名称空间的名称来限定他。

b.函数的主要优点之一是根据需要可以在程序的不同位置执行任意次。如果不能将代码块封装到函数中，则程序将最终成为庞然大物，因为那样通常需要再程序的不同位置复制相同的代码。使用函数还可以将程序分为易于管理的代码块，以方便开发和测试，复杂的大型程序如果包含几个小代码块，就比编写为一个大代码块更容易理解和测试。

c.函数头

int num(double a,int b);

本行由三部分组成:

a.返回值的类型(本例中int)

b.函数名(本例中num)

c.圆括号中的函数形参(本例中是a和b，分别为double和int类型)

注意:函数头末尾和函数体右大括号后面都不需要分号。如果函数没有返回值，则由void来指定返回类型。(void mynum(int a));

 

简单介绍完函数，下面其实是好几个例子组成的:

下面这是main主函数和一些要调用函数的声明：

#include "stdafx.h"

using std::cin;
using std::cout;
using std::endl;
//1.值传递(pass by value )
int _value(int a,int b);
//2.地址传递(pass by pointer)
int _pointer(int* a);
//3.引用传递(pass by reference)
int _reference(int &a,int &b);
//4.函数返回指针
int*  _rpointer(int a,int b);
//5.函数中的静态变量
int _countnum(int a,int b);
//6.递归函数调用
int _chengnum(int n);
int _tmain(int argc, _tchar* argv[])
{
    int a{ 5 };
    int b{ 5 };
    int _vnum{};
    int* _pnum{&a};
    int _rnum{};

    int* _prnum{};
    int _cnum{};
    //1.值传递
    printf("调用传值前：a=%d,b=%d,vnum=%d\n", a, b, _vnum);
    _vnum = _value(a, b);
    printf("传值后：a=%d,b=%d,vnum=%d\n", a, b, _vnum);
    //2.地址传递
    printf("调用传地址前:a=%d,*_pnum=%d\n", a, *_pnum);
    *_pnum = _pointer(&a);
    printf("传地址后:a=%d,*_pnum=%d\n", a, *_pnum);
    //3.引用传递
    printf("调用传引用前：a=%d,b=%d,_rnum=%d\n", a, b, _rnum);
    _rnum = _reference(a, b);
    printf("传引用后：a=%d,b=%d,_rnum=%d\n", a, b, _rnum);

    //4.函数返回指针
    _prnum = _rpointer(a,b);
    cout << "_prnum = " << *_prnum << endl;

    delete _prnum;                       //释放掉内存
    _prnum = nullptr;

    //5.函数中的静态变量
    _vnum = _countnum(a, b);
    _vnum = _countnum(a, b);
    _vnum = _countnum(a, b);
    _vnum = _countnum(a, b);

    //6.递归
    int c{ 5 };
    _cnum = _chengnum(c);
    cout << c << "的阶乘是:" << _cnum << endl;

    system("pause");
    return 0;
}

实现被调用的函数

1.给函数传递实参:

int _value(int a, int b)
{
    a += 5;        //改变形参a的值
    b += 5;        //改变形参b的值
    return a + b;
}

2.地址传递

当使用指针作为实参时，按值传递机制仍然像以前一样工作。但指针是另一个变量的地址，如果创建该地址的副本，则副本仍然指向相同的变量。以指针作为形参可以使函数处理调用者实参。

int _pointer(int* a)
{
    //return &a;
    *a += 5;       //改变指针指向的地址
    return *a;
}

3.引用传递

给函数传递实参的第二种方法:形参其实是引用被传递实参的别名，该机制不再复制所提供的实参。允许函数直接访问调用函数中的实参。

当使用类类型对象时，对函数使用引用形参具有特殊的意义。对象可能会很大，很复杂，此时复制过程中，可能会耗费很多时间。在这样的情况下，使用引用形参可以大大加快代码的执行速度。

可以给函数的形参使用const修饰符,以告诉编译器我们不想以任何方式修改这个形参。

int _reference(int &a, int &b)
{
    a += 5;        //改变形参a的值
    b += 5;        //改变形参b的值
    return a + b;
}

4.函数返回指针

返回地址的规则:永远不要从函数中返回局部自动变量的地址。

这样做很危险的，因为：函数_rpointer(a,b)中的变量num是在该函数开始执行时创建的，并在该函数退出时被销毁，因此指针ptr指向的内存不在包含原来的变量值。先前分配给num的内存现在可能用于其他目的。

改正:我们的意图是返回指向某些有用数据的指针，以便最终能够返回多想数据。一种方法是动态分配内存。使用操作符new，可以在空闲存储器中创建一个新变量，该变量一直存在，知道最终被delete销毁，或者知道程序结束。

注意：动态分配内存时，每次调用该函数时都要多分配一些内存。当然不需要内存时，主调程序需要将其删除，但实践中

人们很容易忘记这么做，结果就是空闲存储器的内存被逐渐消耗，知道某个时刻内存用尽且程序失败。这类问题称为内存泄漏。

int* _rpointer(int a, int b)
{
    //int num = a + b;
    //num += 10;

    //改正后
    int* num{ new int{} };
    *num = a + b;
    *num += 10;
    return num;
}

5.函数中的静态变量

有些时候用自动变量不能完成的。例如不能计算调用函数的次数，因为无法再多次调用中累积数值。有多重方法可以解决该问题。例如,可以使用引用形参来更新调用程序中的计数器，但如果程序中的许多不同位置都调用该函数，这种方法将无济于事。还可以使用在函数中递增的全局变量，但这样做是有风险的，因为程序中任何位置都可以访问全局变量，他们非常容易被以外修改。在具有多个访问全局变量的执行线程的应用程序中，全局变量同样是危险的，因此必须特别注意管理从不同线程中访问全局变量的方式。当多个线程都可以访问某个全局变量时，必须处理的基本问题：一个线程使用全局变量时，另一个线程可以修改该变量的值。在这样的情况下，最好的解决方案是完全避免使用全局变量。

函数内静态变量的初始化仅仅发生在第一次调用该函数的时候。事实上，初次调用函数时该变量包含的任何值都可以在下次调用时使用。

关于static关键字

a.静态变量，分配在静态存储区，在数据段中。函数退出之后，变量值不变。

b.作用域，全局的静态变量、静态函数只能在本文件中使用。（不同于一般全局变量）

局部的静态变量同函数的局部变量

注：局部静态变量占用内存时间较长，并且可读性差，因此，除非必要，尽量避免使用局部静态变量。

作用:

a、非静态全局变量的作用域是整个源程序 ，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。

b、静态全局变量则限制了其作用域， 即只在定义该变量的源文件 内有效，在同一源程序的其它源文件(即声明了该变量的cpp文件, 或包含该变量声明头文件的cpp文件)中不能使用它。

在c++中，内存分成5个区，他们分别是堆、栈、*存储区、全局 / 静态存储区和常量存储区。

int _countnum(int a, int b)
{
    a += 5;
    b += 5;
    static int countnum{};
    countnum++;
    cout << "调用次数:"<
6.递归函数 

递归函数调用:当函数包含自身的调用时，称之为递归函数。递归的函数调用也可以是间接的，即函数fun1 

调用函数fun2,后者再调用fun1。 

递归可以看做实现无穷循环的一种方法，如果我们不小心，就会发生这种情况。无穷循环将锁住计算机，需要按ctrl+alt+del组合键才能终止程序，这永远是件非常令人讨厌的事情。避免无穷循环的前提是函数包含某种使递归调用过程停止的方法。 

在物理和数学方面，有许多问题可以被视为包含递归。整数的阶乘就是个简单的例子。对于给定的整数n来说，其阶乘就是乘积1*2*3*。。。*n
注意:除非遇到的问题特别适用于使用递归函数，或者没有明显的替代方法，否则使用其他方法一般(如循环)会更好。使用循环比使用递归的函数调用的效率更高。在深度适中的递归调用中，系统开销也可以大大超过使用循环时的开销。当然这样说的意思不是我们永远不应该使用递归。当问题适于用递归函数调用来解决时，递归就是非常强大的技术可以大大简化代码。
int _chengnum(int n)
{
    static int countnum{n};                           //声明一个静态变量；
    countnum *= (n - 1);
    cout << countnum << endl;
    if (n > 2)
        return _chengnum(n - 1);
    else
    {
        return countnum;
    }
}