C++ Primer学习笔记（三） C++中函数是一种类型！！！

C++中函数是一种类型！C++中函数是一种类型！C++中函数是一种类型！

函数名就是变量！函数名就是变量！函数名就是变量！

（---20160618最新消息，函数名不是变量名。。。囧）

（---20160714最新消息，C++没有函数类型。。。囧）

（---但是，我认为把它们当成类型和变量更容易理解！！！）

重要的事情要说三遍。。。

接 C++ Primer学习笔记（二）

类的构造函数

与类同名，且无返回类型。

同类的成员函数一样，也可以在类中声明，在类外定义。

格式：

　　类名(): 成员1(成员1初始化值), 成员2(成员2初始化值) { }

以上，冒号至大括号中间的部分，称为构造函数的初始化列表，用于调用类成员的构造函数来初始化。

没有在初始化列表中显式指定初始化的成员，将会隐式的初始化。

 

如果没有显式的定义一个构造函数，那编译器会生成一个默认构造函数。

--建议只适用于仅包含类类型成员的类。

默认构造函数不会初始化内置类型成员！

 

 

类的一般使用方式：有类user，则user.h是声明，user.cpp是定义，成员函数通常放入user.cpp中。

 

#include <iostream>
#include <string>
 
using namespace std;
 
//test const
int main(){
    //------------测试非引用------------
    int no=;
    const int no2=no; //OK
    int no3=no2; //OK!
    //上面得出结论：非引用类型的赋值无所谓const 
 
    //------------测试引用------------
    int &noref=no;
    const int &noref1=no;
 
//    int &no2ref=no2;
    const int &no2ref1=no2;
 
    int &no3ref=no3;
    const int &no3ref1=no3;
    // 上面得出结论：const引用可以指向const及非const。但非const引用只能指向非const。
 
    //------------测试指针------------
    int *pno=&no;
    const int *pno_1=&no;//指向const的指针，可以指向非const 
 
//    int *pno2=&no2;//指向非const的指针，只能指向非const
    const int *pno2_1=&no2;
 
    int *pno3=&no3;
    const int *pno3_1=&no3;
    // 上面得出结论：见备注    
 
    return ;
}

 

//我擦，有谁能告诉我int怎么转成string吗？例如姓名年龄 一起输出。

 

 

如果两个函数声明的返回类型和形参表完全匹配， 则将第二个函数声明视为第一个的重复声明。如果两个函数的形参表完全相同，但返回类型不同，则第二个声明是错误的。

形参与 const 形参的等价性仅适用于非引用形参。有 const 引用形参的函数与有非 const 引用形参的函数是不同的。类似地，如果函数带有指向 const 类型的指针形参， 则与带有指向相同类型的非 const 对象的指针形参的函数不相同。

注意：函数名也是变量，所以也存在被屏蔽的可能。--函数是一种类型！！！

例如：有个init()，而局部变量int init=0;则会屏蔽掉init()！！！

即：局部变量能屏蔽掉同名函数！！！

同理：局部声明的函数，将屏蔽外部声明的函数。。。屏蔽所有同名的函数，包括重载的。

 

在 C++ 中，名字查找发生在类型检查之前。

仅当形参是引用或指针时，形参是否为 const 才有影响。
可基于函数的引用形参是指向 const 对象还是指向非 const 对象， 实现函数重载。将引用形参定义为 const 来重载函数是合法的，因为编译器可以根据实参是否为 const 确定调用哪一个函数。

重复强调， 编译器可以判断： 如果实参是 const 对象，则调用带有 const* 类型形参的函数；否则，如果实参不是 const 对象， 将调用带有普通指针形参的函数。

但是，不能基于指针本身是否const来实现函数重载！

f(int *);

f(const int *);//redeclaration

因为const的是指针，而非指针所指向的类型。在上述两种情况中， 都复制了指针， 指针本身是否为 const 并没有带来区别。

 

 

函数的指针，是指向函数类型。

像其他指针一样，函数指针也指向某个特定的类型--函数类型。

函数类型由其返回类型以及形参表确定， 而与函数名无关。

例如：bool (*pf) (const string &, const string &); // pf的括号是必须的

这个语句将 pf 声明为指向函数的指针，它所指向的函数带有两个 const string& 类型的形参和 bool 类型的返回值。

可以使用typedef简化函数指针的使用。

typedef bool (*cmpFcn) (const string &, const string &);

上面定义了一个指向函数的指针类型的名字：cmpFcn。

 

 

在引用函数名但又没有调用该函数时，函数名将被自动解释为指向函数的指针。
所以，可以使用函数名对函数指针进行初始化或赋值。

cmpFcn pf1=;    //ok
cmpFcn pf2=lengthCompare;    //ok
pf1=lengthCompare;    //ok
pf2=pf1;    //ok   

直接引用函数名，等效于在函数名上取地址。

cmpFcn pf1=lengthCompare;
cmpFcn pf2=&lengthCompare;

 

不同类型的函数指针不能转换！！！

 

通过函数指针可以调用函数，而且不需要显式解引用操作！

lengthCompare("hi", "bye"); //直接调用函数
pf("hi", "bye"); //隐式解引用！
(*pf)("hi", "bye"); //显式解引用！

 

函数指针作为形参！卧槽，感觉要进入lambda了！

void func(const string &, const string &, bool(const string &, const string &)); //隐式
void func(const string &, const string &, bool (*)(const string &, const string &)); //显式

 

函数指针作为返回值！卧槽，这绝对是lambda！

int (*ff(int))(int*,int); //QNMD
其中：ff(int) 是函数，返回 int (*)(int*,int)，也就是返回函数指针。

 

#include <iostream>
#include <string>
using namespace std;
 
int strCmp(const string&, const string&);
int xxx(const string&, const string&);
 
//函数指针
int main(){
    string str1="hehe";
    string str2="abc";
 
    cout<<"strCmp(str1, str2):"<<strCmp(str1, str2)<<endl;
 
    //函数指针
    int (*ext)(const string&,const string&); //(*strCmp)的括号是必须的。如果声明：int *strCmp(const string&, const string&) 
 
    typedef int (*fp)(const string&, const string&);//类似声明
    fp p0=;
    cout<<"p0:"<<p0<<endl;
    fp p1=strCmp;
    fp p2=p1;
    p0=p2;
 
    cout<<"p0(\"---\", \"xxxxxxx\")"<<p0("---", "xxxxxxx")<<endl;
    cout<<"p1(str2, str1):"<<p1(str2, str1)<<endl;     //why?
    cout<<"p2(str2, str1):"<<p2(str2, str1)<<endl; //why?    
 
    fp p3=xxx;
    cout<<"p3:"<<p3<<endl;//why 1?
    cout<<"p3(\"a\", \"b\"):"<<p3("a", "b")<<endl;
 
    ext =xxx;
    cout<<"ext:"<<ext<<endl;//why 1?
    cout<<"ext(str1, str2):"<<ext(str1, str2)<<endl;
 
    //结论：type (*pf)(parameter list)就已经定义了一个函数指针pf。
  //typedef可以定义函数指针的类型，而非函数指针。该类型可以定义指针。
  //0函数指针输出0；其他则输出1。
  //通过函数指针可以直接调用函数：只要后面跟上实参列表即可！函数指针会隐式的解引用--当然也可以显式的解引用！
 
    return ;
} 
 
int strCmp(const string &str1, const string &str2){
    return str1.size()-str2.size();
}
 
int xxx(const string &str1, const string &str2){
    return ;
}

 

 

而所谓返回函数指针，或者作为形参，其实都是操作函数指针变量---需要注意，只是返回，不是调用函数！！

而且，建议配合typedef 使用，否则难明白。

例如：

　　int (*func(p.l.))(p.l. of fp);  //p.l. = parameter list;   fp=function pointer

可以先定义：typedef  int (*fp)(p.l. of fp);

然后，前面就可以写成：fp func(p.l.);

 

注意：允许将形参定义为函数类型，但函数的返回类型则必须是指向函数的指针，而不能是函数！！！

具有函数类型的形参所对应的实参，将被自动转换为所指向相应函数类型的指针。但是，当返回的是函数时，同样的转换操作无法实现！

typedef int func(p.l);//这里的func是函数类型，不是函数指针！所有int xxx(p.l)形式的函数！
void f1(func); //ok  函数类型可以作为形参
func f2(int); //error 函数类型不能作为返回值！
func *f3(int); //ok 函数类型指针可以作为返回值（其实就是函数指针）

上面的关键是：函数是一种类型！！！函数名是变量！！！