返回函数指针的函数
 
函数指针
指针函数
返回函数指针的函数
  
 

 
函数指针
 
 
 
类似于数组名，在C语言中函数名的实际就是函数所在空间的首地址，故也可声明相应类型的函数指针用于指向相应的实际函数，更深层次甚至可以声明函数指针数组和返回函数指针的函数。
 
 
定义格式：声明函数指针时需要指出返回类型和所有形参类型，即对于指向int add(int a,int b);的函数指针可以声明为
 
int (*p)(int ,int ) = add;
 
这里的p即为指向add的函数指针，注意*p左右的括号不可省略，否则优先级原则p前面的*会和int结合从而变成int* p（int, int）；即被理解为对函数p的声明，返回值为整型指针。
 
 
指针函数
 
 
返回指针的函数，有必要区分于函数指针的概念
 
返回函数指针的函数
 
 
 
C++不允许定义返回函数的函数，但可以定义返回函数指针的函数来实现同python类似的事情，即函数的返回值是一个指向另一个函数的指针，故对其返回值又可传入实参进行并列调用（如：fun1(a,b)(a,b);这里假设fun1的返回值是指向fan2的指针故后面两个参数即是传给fun2的实参）
 
 
定义格式：和普通函数的区别主要在于定义时函数的返回值类型，函数返回值的类型应该是指向某类函数的函数指针类型，但由于该类型实际书写方式复杂，故可考虑为该指针类型创建别名，然后同普通数据类型一样直接写在函数名之前表达返回该类型就行了
 
//e.g:
using funp = int(*)(int, int);
 // <==>typedef int(*funp)(int, int);
 
 int add(int a, int b) {
 	return a + b;
 }
 funp fun(int& a, int& b) {
 	int temp = a;
 	a = b;
 	b = temp;
 	return add;
 }
 
 int main() {
 	int a = 5, b = 10;
 	fun(a, b)(a, b);
 	return 0;
 }
 
这里的funp就是对int( )(int,int)类型的函数指针创建的别名，在定义返回该函数指针类型的函数时直接定义funp fun(…){…}就行。
 

问题源于看剑指offer上的一道面试题，题目如下：
 

class A{
private:
    int value;
public:
    A(int n){ value = n; }
    A(A other){ value = other.value; }
    void Print() {cout<<value<<endl; }
};
int main(void)
{
    A a = 10;
    A b = a;
    b.Print();
    return 0;
}

 
 
对上面这段代码进行分析编译运行的结果是：
 
A、编译错误   B、编译成功，运行时程序崩溃     C、编译运行正常，输出10
 
 
 
答案：A、编译错误。复制构造函数A（Aother）传入的参数是A的一个实例。由于是传值参数，我们把形参复制到实参会调用复制构造函数。因此如果允许复制构造函数传值，就会在复制构造函数内调用复制构造函数，就会形成永无休止的递归调用从而导致栈溢出。
 
 
 
敲黑板划重点：C++的标准不允许复制构造函数传值参数，只能将构造函数修改为A（const A& other），也就是把传值参数改为常量引用。（注意：传指针也是不可以的，只能改为引用）。
 
 
 
一开始不理解为什么会无限循环递归下去这个过程。于是在网上查了一下。用下面这个例子来深入理解一下这个过程。
 
 
 

#include<iostream>
usingnamespace std;
class CExample
{
private:
    int m_nTest;
public:
    CExample(int x) : m_nTest(x)      //带参数构造函数
    {
        cout << "constructor withargument"<<endl;
    }
    // 拷贝构造函数，参数中的const不是严格必须的，但引用符号是必须的
    CExample(const CExample & ex)     //拷贝构造函数
    {
        m_nTest = ex.m_nTest;
        cout << "copyconstructor"<<endl;
    }
    CExample& operator = (const CExample&ex)   //赋值函数(赋值运算符重载)
    {
        cout << "assignmentoperator"<<endl;
        m_nTest = ex.m_nTest;
        return *this;
    }
    void myTestFunc(CExample ex)
    {
    }
};
int main(void)
{
    CExample aaa(2);
    CExample bbb(3);
    bbb = aaa;
    CExample ccc = aaa;
    bbb.myTestFunc(aaa);
    return 0;
}


  
 
这段代码运行后输出如下：
 
constructorwith argument
 
constructorwith argument
 
assignmentoperator
 
copyconstructor
 
copyconstructor
 
 
 
程序分解分析：
 
第一个constructorwith argument，来源于CExample aaa(2);因为要对aaa实例化并初始化，所以要调用带参数的构造函数
 
第二个constructorwith argument，来源于CExample bbb(3);同理。
 
assignmentoperator，来源于bbb =aaa;
 
第一个copyconstructor，来源于CExample ccc = aaa;这个和上面为什么有区别呢？原因是因为bbb对象已经实例化了，不需要构造，所以将aaa赋值给bbb，只会调用赋值函数。但是ccc还没有实例化，因此调用的是拷贝构造函数，构造出ccc，而不是赋值函数。
 
第二个copyconstructor，来源于bbb.myTestFunc(aaa);。过程是这样：首先将aaa作为参数传递给bbb.myTestFunc(CExample ex)，即CExample ex = aaa；和上面一样，所以还是拷贝赋值函数。
 
 
 
如果拷贝构造函数是传值而不是传引用，当调用ccc.CExample(aaa)时，aaa作为参数传值给ccc.CExample(CExample ex)，即CExample ex = aaa，因为ex没有被初始化，所以会继续调用拷贝构造函数，接下来是构造ex，也就是ex.CExample(aaa)，必然又会有aaa传给CExample(CExample ex)，即CExample ex = aaa；那么又会触发拷贝构造函数，这样就无限递归下去了。
 
 
 
所以，拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝，而是避免拷贝构造函数无限制的递归下去。
 
下面这几种情况下会调用拷贝构造函数
 
（1）显式或隐式地用同类型的一个对象来初始化另外一个对象。如上例中的CExample ccc = aaa;
 
（2）作为实参传递给一个函数。如上例中的bbb.myTestFunc(aaa);
 
（3）在函数体内返回一个对象时，也会调用返回值类型的拷贝构造函数
 
（4）初始化序列容器中的元素时。比如vector<string> svec(5)，string的缺省构造函数和拷贝构造函数都会被调用。
 
（5）用列表的方式初始化数组元素时。string a[] = {string(“hello”),string(“world”)};会调用string的拷贝构造函数。

    函数千万不要返回局部对象的引用或指针 

     局部变量在函数里面，当函数执行结束后将释放局部变量，如果返回引用或批针这个时候引用或指针指向所指向的内存空间已经释放。指针和引用将是垂悬指针。很危险！
 
 但是如果返回的“局部变量”是堆中的内存值就可以返回了
 
 
 
 C++函数为什么要使用引用？
 
 
 C语言之中大量利用指针作为形参或者函数返回值，这是由于值拷贝会有很大的消耗（比如传入传出一个大的结构体）。所以在C++之中使用引用作为函数参数和返回值的目的和使用指针是一样的。而且形式上更加直观，所以C++提倡使用引用。
 
 
 
 
 
     1）返回非引用类型：函数的返回值用于初始化在跳出函数时候创建的临时对象。用函数返回值来初始化临时对象与用实参初始化形参的方法是一样的。如果返回类型不是引用的话，在函数返回的地方，会将返回值复制给临时对象。且其返回值既可以是局部对象，也可以是表达式的结果。
 
 
     2）返回引用：当函数返回引用类型的时候，没有复制返回值，而是返回对象的引用（即对象本身）。
 
 
 函数返回引用：实际上是一个变量的内存地址，既然是内存地址的话，那么肯定可以读写该地址所对应的内存区域的值，即就是“左值”，可以出现在赋值语句的左边。
 
 
     3) 函数返回引用的时候，可以利用全局变量（作为函数返回），或者在函数的形参表中有引用或者指针（作为函数返回），这两者有一个共同点，就是返回执行完毕以后，变量依然存在，那么返回的引用才有意义。
    1、引用其实本质就是地址
 
 
  
 
  
 
  2、当函数返回值类型为引用时，一般就用引用类型去接收，或者就使用了引用的作用，如果用非引用类型接受，就等于将函数返回的引用的数据值，复制给了该接收对象，和函数返回非引用类型是一样的效果。
 
 
    3、当函数返回值类型为引用时，如果不考虑接收问题，则有一个特性，则是可以直接操作该函数返回的引用，如放在=左面 +=等.
 
 
 
 小结：
 
 
 （1）使用引用当作函数参数和返回值，效率更高。
 
 
 （2）函数返回的对象引用，必须在调用函数前就已经存在，不允许返回局部变量的引用！
 
 
 （3）当不希望返回的对象被修改的时候，可以添加const。
 
 
 
  
 class Node  
 {  
 public:  
     double a;  
     int b;  
     char c;  
   
     Node(double a=0,int b=0,char c=0)  
     {  
         this->a=a;  
         this->b=b;  
         this->c=c;  
     }  
   
         //拷贝构造函数  
     //Node(const Node &n)  
     //{  
     //  a=n.a;  
     //  b=n.b;  
     //  c=n.c;  
     //}  
 };  
   
 Node& GetNode()  
 {  
     Node str(10.0,2,'c');  
     return str;  
 }  
   
 int main()  
 {  
     Node newnode=GetNode();   
     cout<<newnode.a<<" "<<newnode.b<<" "<<newnode.c<<endl;  
     return 0;  
 }  
 
  
 在上面的代码中，最后能够输出正确的值，然而在函数GetNode()中，str是一个局部的对象，内存空间在栈上，当函数退出时，str的内存空间被回收，这是在高级语言的层面上讲的。但是为什么最后的结果是正确的？原因就是Node newnode=GetNode();这句调用的是默认的拷贝构造函数，如果是自己重新重写拷贝构造函数，而不用默认的拷贝构造函数，那么这段代码就绝对有问题，最后输出的是未定义的数。
 
  
 然而，为什么用默认的拷贝构造函数就能够正确的输出最后的值呢？
 
  
 通过调用这段代码的反汇编我们可以看到：
 
  
  
 
  
  Node newnode=GetNode(); 
 013215FE  call        GetNode (1321019h) 
 01321603  mov         ecx,dword ptr [eax]               //eax调用GetNode 函数返回的栈的栈顶指针
 01321605  mov         dword ptr [newnode],ecx      
 01321608  mov         edx,dword ptr [eax+4] 
 0132160B  mov         dword ptr [ebp-10h],edx //这句为double的a数据成员赋值
 0132160E  mov         ecx,dword ptr [eax+8] 
 01321611  mov         dword ptr [ebp-0Ch],ecx  //这句为int的b数据成员赋值
 01321614  mov         edx,dword ptr [eax+0Ch] 
 01321617  mov         dword ptr [ebp-8],edx  //这句为char的c数据成员赋值
  cout<<newnode.a<<" "<<newnode.b<<" "<<newnode.c<<endl;
 
  
  
 
  
 也就是说直接调用默认的拷贝构造函数（或者默认的赋值函数），函数返回，在函数中的局部变量的销毁，其实在栈中只是栈顶的指针的移动，仍然还是可以为其赋值的。
 
  
  
 
  
 然而：
 
  
  Node &newnode=GetNode(); 
  cout<<newnode.a<<" "<<newnode.b<<" "<<newnode.c<<endl;//能够输出正确的值
  cout<<newnode.a<<" "<<newnode.b<<" "<<newnode.c<<endl;//不能输出正确的值
  cout<<&newnode<<endl;
 
  
  
 
  
对于代码，newnode是对GetNode函数的引用，当函数结束时，其实是已经吧局部对象str销毁了，但是由于输出的结果仍然还在堆栈中，所以第一个能够输出正确的值，第二个是由于堆栈已经被其他的数覆盖，所以不能输出正确的值，而且这个对象也不能为其赋值，因为它的内存空间已经不存在了.
 
 
 

1.什么是聚合函数
 
        聚合函数是hive内置函数，聚合函数对一组值执行计算，并返回单个值。 在Hive的聚合中，如果某个聚合列的值中有null，则包含该null的行将在聚合时被忽略除，了 COUNT 函数以外。为了避免这种情况，可以使用COALESCE来将null替换为一个默认值。 聚合函数经常与 SELECT 语句的 GROUP BY 子句一起使用。换句话说使用聚合函数时，一个列字段要不在group by里，要不必须在聚合函数里面，否则报错。
 
      hive中所有的内嵌函数：Hive所有内嵌函数wiki
 
           下面是hive中自带的内置聚合函数列表，蓝色为常用：
 
 
返回类型
 
 
函数名
 
 
描述
 
 
BIGINT
 
 
count(*)
 
count(expr)
 
count(DISTINCT expr[, expr_.])
 
 
count(*) – 返回检索到的行的总数，包括含有NULL值的行。count(expr) – 返回expr表达式不是NULL的行的数量count(DISTINCT expr[, expr]) – 返回expr是唯一的且非NULL的行的数量
 
 
DOUBLE
 
 
sum(col)
 
sum(DISTINCT col)
 
 
对组内某列求和（包含重复值）或者对组内某列求和（不包含重复值）
 
 
DOUBLE
 
 
avg(col),
 
avg(DISTINCT col)
 
 
对组内某列元素求平均值者（包含重复值或不包含重复值）
 
 
DOUBLE
 
 
min(col)
 
 
返回组内某列的最小值
 
 
DOUBLE
 
 
max(col)
 
 
返回组内某列的最大值
 
 
DOUBLE
 
 
variance(col),
 
var_pop(col)
 
 
返回组内某个数字列的方差
 
 
DOUBLE
 
 
var_samp(col)
 
 
返回组内某个数字列的无偏样本方差
 
 
DOUBLE
 
 
stddev_pop(col)
 
 
返回组内某个数字列的标准差
 
 
DOUBLE
 
 
stddev_samp(col)
 
 
返回组内某个数字列的无偏样本标准差
 
 
DOUBLE
 
 
covar_pop(col1, col2)
 
 
返回组内两个数字列的总体协方差
 
 
DOUBLE
 
 
covar_samp(col1, col2)
 
 
返回组内两个数字列的样本协方差
 
 
DOUBLE
 
 
corr(col1, col2)
 
 
返回组内两个数字列的皮尔逊相关系数
 
 
DOUBLE
 
 
percentile(BIGINT col, p)
 
 
返回组内某个列精确的第p位百分数，p必须在0和1之间
 
 
array<double>
 
 
percentile(BIGINT col, array(p1 [, p2]...))
 
 
返回组内某个列精确的第p1，p2，……位百分数，p必须在0和1之间
 
 
DOUBLE
 
 
percentile_approx(DOUBLE col, p [, B])
 
 
返回组内数字列近似的第p位百分数（包括浮点数），参数B控制近似的精确度，B值越大，近似度越高，默认值为10000。当列中非重复值的数量小于B时，返回精确的百分数
 
 
array<double>
 
 
percentile_approx(DOUBLE col, array(p1 [, p2]...) [, B])
 
 
同上，但接受并返回百分数数组
 
 
array<struct {'x','y'}>
 
 
histogram_numeric(col, b)
 
 
使用b个非均匀间隔的箱子计算组内数字列的柱状图（直方图），输出的数组大小为b，double类型的(x,y)表示直方图的中心和高度
 
 
array
 
 
collect_set(col)  超常用
 
一般配合concat_ws使用
 
 
返回消除了重复元素的数组，去重
 
 
array
 
 
collect_list(col)  超常用
 
一般配合concat_ws使用
 
 
返回允许重复元素的数组，不去重
 
 
INTEGER
 
 
ntile(INTEGER x)
 
 
该函数将已经排序的分区分到x个桶中，并为每行分配一个桶号。这可以容易的计算三分位，四分位，十分位，百分位和其它通用的概要统计
 
2.常用聚合函数使用演示
 
1. 个数统计函数: count
 
语法: count(*), count(expr), count(DISTINCT expr[, expr_.])
 
返回值: int
 
说明: count(*)统计检索出的行的个数，包括NULL值的行；count(expr)返回指定字段的非空值的个数；count(DISTINCTexpr[, expr_.])返回指定字段的不同的非空值的个数
 
举例：
 
hive> select count(*) from lxw_dual;
 
         20
 
hive> select count(distinct t) fromlxw_dual;
 
        10
 
2. 总和统计函数: sum
 
语法: sum(col), sum(DISTINCT col)
 
返回值: double
 
说明: sum(col)统计结果集中col的相加的结果；sum(DISTINCT col)统计结果中col不同值相加的结果
 
举例：
 
hive> select sum(t) from lxw_dual;
 
         100
 
hive> select sum(distinct t) fromlxw_dual;
 
         70
 
3. 平均值统计函数: avg
 
语法: avg(col), avg(DISTINCT col)
 
返回值: double
 
说明: avg(col)统计结果集中col的平均值；avg(DISTINCT col)统计结果中col不同值相加的平均值
 
举例：
 
hive> select avg(t) from lxw_dual;
 
           50
 
hive> select avg (distinct t) fromlxw_dual;
 
            30
 
4. 最小值统计函数: min
 
语法: min(col)
 
返回值: double
 
说明: 统计结果集中col字段的最小值
 
举例：
 
hive> select min(t) from lxw_dual;
 
        20 
 
5. 最大值统计函数: max
 
语法: max（col)
 
返回值: double
 
说明: 统计结果集中col字段的最大值
 
举例：
 
hive> select max(t) from lxw_dual;
 
         120 
 
6.非空集合总体变量函数: var_pop
 
语法: var_pop(col)
 
返回值: double
 
说明: 统计结果集中col非空集合的总体变量（忽略null
 
3.聚合函数使用注意事项
 
1.聚合条件--HAVING，从Hive0.7.0开始HAVING被添加到Hive作为GROUP BY结果集的条件过滤。HAVING可以作为子句的替代。
 
hive> SELECT sex_age.age FROM employee GROUP BY sex_age.age HAVING count(*) >=1;
 
2.聚合函数经常与 SELECT 语句的 GROUP BY 子句一起使用。换句话说使用聚合函数时，一个列字段要不在group by里，要不必须在聚合函数里面，不能单独出现，否则报错。
 
1.只有聚合函数，没有group by ，没问题
hive (default)> select sum(a),count(distinct b)  from fdm_sor.tmp_aaaaa;
   OK
   2	1
2.有聚合函数，又有别的列c，但是没有用group by，报错
hive (default)> select sum(a),count(distinct b) ,c   from fdm_sor.tmp_aaaaa;
FAILED: SemanticException [Error 10025]: Line 1:33 Expression not in GROUP BY key 'c'

3.聚合函数配合group by 一起使用
select sum(a),count(distinct b) , c from fdm_sor.tmp_aaaaa  group by c;
OK
2	1	2019-05-22 21:23:34

 
3.常用的collect_list与collect_set的使用，区别就是前者不去重，后者去重
    collect_list，与collect_set的使用，这个使用好处就是可以轻松明白group by的原理,因为collect_list这个函数可以将分组后不可见的其他字段的情况以数组的形式展示出来，比如这里用filter_name分组，通过collect_list函数可以清晰地看到每个filter_Name组里的path_id的情况，并对些组里的字段进行统计分析
 
3.1演示1
 
 select filter_name ,
        collect_list(path_id),
        collect_set(path_id),
        concat_ws('@',collect_list(path_id)) a,
        concat_ws('@',collect_set(path_id)) b,
        concat_ws('@',collect_set(market_type)) c

from FDM_SOR.T_FIBA_MULTI_UBA_CFG_PATH_DETAIL_D 
where path_id >89
group by filter_name 
 
结果如下：
 
 
3.2 演示2对分组进行计算 
 
 select filter_name ,
        collect_list(path_id),
        collect_set(path_id),
        concat_ws('@',collect_list(path_id)) a,
        concat_ws('@',collect_set(path_id)) b,
        concat_ws('@',collect_set(market_type)) c

from FDM_SOR.T_FIBA_MULTI_UBA_CFG_PATH_DETAIL_D 
where path_id >89
group by filter_name
having  count(path_id)>3 --按filter_name分组，且要求每个分组里的path_id的个数大于3个。
---having是对分组后每组进行统计的。