一、函数的结构
         1、函数头的通式
                      return_type function_name(parameter_list)
         2、按值传递参数
                      在按值传递机制中，我们指定的变量或者常量实参根本没有被传递给函数。而是系统创建这写实参的副本，并将这些副本用作被传递的值。
         3、传指针
                      在函数内，操作的是指针的副本，但是副本跟实参都存储的是实际操作数的地址，所以操作副本的内容也就是在操作实参的内容。
         4、传递数组            
                      编译器将数组名转换为指针，指向数组头部的指针副本通过安值传递机制被传给函数。
                      double average(double array[],int count);      传递数组函数的声明(可以处理任意长度的数组)。
                      double average(double* array,int count);       直接传递指针，等同直接传递数组名，调用方式没有任 何变化。
                      double values[]={1.0,2.0,3.0,4.0,5.0};         要传递的数组。
                      average(values,5);                             传递数组函数的调用。
                     
                      数组是唯一不能被按值传递机制保护的类型。
                     
                      double yield(double beans[2][4]);
                      double yield(double beans[][4],int index);     index提供第一维的参数。
         5、传递引用
                     double average(int &age);
         6、const传递
                     double average(const int& age);                 在函数中age不能被修改。
                     我们可以编写直接访问调用者实参的函数，而且避免了按值传递机制中隐式复制开销。
                     如果我们不打算修改某个实参，则只需引用使用const修饰符，就能避免该参数被意外修改。
                    
         7、接受数量不定的函数参数            
                     int sumValues(int first,...);                    通过将省略号写在函数定义中形参表的后面，表示可以提供不定个数的实参。
                                                      
二。函数返回值
         1、返回指针
                    double* treble(doulbe date);     return &value;
                   
                    永远不要从函数中返回局部自动变量的地址。 
                    int main(void)
                    {  
                        double num=5.0;
                        doulbe* ptr=0;
                        ptr=treble(num);
                       
                        delete ptr;
                        return 0;
                    }           
                    double* treble(double data)
                    {
                       double* result= new double(0.0);
                       *result=3.0*data;
                       return result;
                    }   
         2、返回引用
                  double& lowest(double values[],int length);
                 
                  永远不要从函数中返回对局部变量的引用。
                 
         3、函数中的静态变量
                  static int count=0;
         4、递归函数调用   
        
三、函数指针
         1、声明函数指针
                         return_type (*pointer_name)(list_of_parameter_types);
                         例如： double (*pfun)(char*,int);
         2、函数指针初始化
                         long sum(long num1,long num2);
                         long (*pfun)(long,long)=sum;  或者  pfun=sum;
         3、函数指针作为实参
                         double sumarray(double array[],int len,double (*pfun)(double));
                        
                         double squared(double);
                         double cubed(double);
                         double sumarray(double array[],int len,double (*pfun)(double));
                         int main(void)
                         {
                            double array[]={1.5,2.5,3.5,4.5,5.5};
                            int len=sizeof(array)/sizeof(array[0]);
                            sumarray(array,len,squared);
                            sumarray(array,len,cubed);
                            return 0;
                         }
                         double squared(double x)
                         {
                             return x*x;
                         }             
                         double cubed(double x)
                         {
                            return x*x*x;
                         } 
                         double sumarray(double array[],int len,double (*pfun)(double))
                         {
                            double total=0.0;
                            for(int i=0;i<len;i++)
                              total+=pfun(array[i]);
                             return total;
                         }
         4、函数指针的数组
                        double sum(double,double);
                        double product(double,double);
                        double difference(double,double);
                        double (*pfun[3])(double,duoble)={sum,product,difference};
                        调用第二个元素product()函数，我们可以这么写 pfun[1](2.5,3.5);
         5、初始化函数形参
                        int do_id(long arg1=10,long arg2=20,long arg3=30);
         6、异常

四、函数重载
        具有相通的函数名称，但是形参的类型或者形参的数量不同。 注意：不同的返回类型不足以区分函数。
五、函数模板
        函数模板有一个或者多个类型形参，我们通过给模板的每个形参提供具体的类型实参来生产具体的函数。
        1、模板的声明
                     template<class T> T max(T x[],int len)
                     {
                          T max=x[0];
                          for(int i=1;i<len;i++)
                             if (max<x[i])
                                 max=x[i];
                          return max;
                     }