C++基础复习·二

1.续行符 \
#define MAX(a,b) \
((a)>(b) ? (a) : (b))
2.内联函数inline
1).
inline void print(int a, int b)
{
cout << “a = ” << a << endl << “b = ” << b << endl;
}
main::
print(10,30);
编译器编译的时候将内联函数直接展开到调用部分

2).特点
    1）内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。
    2）C++编译器直接将函数体插入在函数调用的地方.
    3）内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)。 
    4）内联函数是一种特殊的函数，具有普通函数的特征（参数检查，返回类型等）.
    5）内联函数由编译器处理，直接将编译后的函数体插入调用的地方,宏代码片段由预处理器处理，进行简单的文本替换，没有任何编译过程。
    6）C++中内联编译的限制： 
        不能存在任何形式的循环语句 
        不能存在过多的条件判断语句 
        函数体不能过于庞大 
        不能对函数进行取址操作 
        函数内联声明必须在调用语句之前 
    7）编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。
        因此，当函数体的执行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义.
3).优缺点
    优点:避免调用时的额外开销(入栈与出栈操作)
    代价:由于内联函数的函数体在代码段中会出现多个“副本”,因此会增加代码段的空间。
    本质:以牺牲代码段空间为代价,提高程序的运行时间的效率。
    适用场景:函数体很“小”,且被“频繁”调用。

3.函数默认参数和占位参数
//2 在默认参数规则 ，如果默认参数出现，那么右边的都必须有默认参数
//所以默认参数一般都放在形参列表的末尾
float volume(float length, float weight = 4,float high = 5)
{
return length*weight*high;
}
int main()
{
float v = volume(10);
float v1 = volume(10,20);
float v2 = volume(10,20,30);
cout<< v << endl;
cout<< v1 << endl;
cout<< v2 << endl;
return 0;
}
4.解决方案–>属性–>启动项目–>当前选定内容
这样做就可以 你当前在编辑那个项目就将哪个项目作为启动项，动态
5.函数重载
1).函数重载的条件
函数名
形参列表（形参个数，形参类型，形参顺序）
与函数返回值无关
int fun1(int a, int b)
{
cout << “fun1:”;
cout << “a = ” << a << “b = ” << b << endl;
return 0;
}
int fun1(int a)
{
cout << “fun1:”;
cout << “a = ” << a << endl;
return 0;
}

    #if 0
    char fun1(int a)
    {
        cout << "fun1:";
        cout << "a = " << a << endl;
        return 0;
    }
    #endif

2). //重载的时候最好不要给形参加默认值，否则容易出现函数调用冲突
    int fun1(int a, int b, int c = 20)
    {
        cout << "fun1:";
        cout << "a = " << a << "b = "  << b <<"c = "<< c << endl;
        return 0;
    }
    main::fun1(10,30)//error,编译器发现有两个可选的函数重载，它不知道该选哪个，所以报错
3).调用准则
    严格匹配,找到则调用。
    通过隐式转换寻求一个匹配,找到则调用。
    没有找到严格匹配项，也未找到隐式转换项，则调用失败
4).重载的底层实现
    重载函数在本质上是相互独立的不同函数
    重载底层是通过name mangling(倾轧)技术,来改名函数名,区分参数不同的同名函数。
    实现原理:用  v  c  i  f l  d  表示  void  char  int  float  long  double  及其引用。
    void  func(char  a);                        //  func_c(char  a)  
    void  func(char  a,  int  b,  double  c);  //func_cid(char  a,  int  b,  double  c)

6.函数指针定义
1).先定义函数类型，再定义函数指针变量
typedef int (MY_FUNC)(int ,int );//定义函数类型
MY_FUNC *fun1 = NULL;
fun1 = fun;
2).先定义函数指针类型，再定义函数指针变量
typedef int (*MY_FUNC_P)(int ,int );
MY_FUNC_P fun2 = NULL;
fun2 = fun;
3).直接定义函数指针变量
int (*fun3)(int ,int );
fun3 = fun;
7.函数指针与函数重载结合–>4.函数指针与函数重载.cpp
int fun1(int a, int b)
{
cout << “fun1:”;
cout << “a = ” << a << “b = ” << b << endl;
return 0;
}
int fun1(int a, int b,int c)
{
cout << “fun1:”;
cout << “a = ” << a << “b = ” << b << “c = ” << c << endl;
return 0;
}
main::
int (*fun3)(int ,int );
//实际上在给函数指针赋值的时候，是会发生函数重载匹配的
//在调用函数指针时，所调用的函数就已经固定了
fun3 = fun;

8.类的访问控制符
public:在类的内部可以访问到，在类的外部也可以访问的到
private:在类的内部可以访问到，在类的外部不可以访问
public:在类的内部可以访问到，在类的外部不可以访问(就单个类来说，其性质跟private一样)
9.同类之间无私处
class Dog
{
private:
int age;
public:
void setAge(int a);
int getAge();
void comparAge(Dog &);
};

void Dog::comparAge(Dog &d2)
{
    if(age > d2.getAge())
        cout<<"狗1比狗2大"<<endl;
    else
        cout<<"狗1比狗2小"<<endl;
}
void Dog::comparAge(Dog &d2)
{       
    //同类之间无私处

    if(age > d2.age)
        cout<<"狗1比狗2大"<<endl;
    else
        cout<<"狗1比狗2小"<<endl;
}

10.封装

封装有2层含义（把属性和方法进行封装  对属性和方法进行访问控制）
封装,可以达到,对内开放数据,对外屏蔽数据,对外提供接口

11.面向对象和面向过程的区别
面向对象与面向过程：
面向对象： 狗.吃(屎)
面向过程： 吃(狗,屎)
12.类在定义时，不能初始化成员变量

class  circle 
{ 
public: 
    double  r; 
    double  pi  =  3.1415926; 
    double  area  =  pi*r*r; 
}; 
int  main(void) 
{ 
    circle  pi; 
    cout  <<  "请输⼊入area"  <<  endl; 
    cin  >>  pi.r; 
    cout  <<  pi.area  <<  endl;     //乱码 
    return  0; 
}

从内存四区图中理解：

        //circle  pi; 
        |---------------|                               
        |               |
        |               |
        |               |
        |               |
        |---------------|
        |               |
    area|   随机*r*r     |
        |               |
        |---------------|
    pi  |               |
        |---------------|
    r   |   随机         |
        |---------------|


        //pi.r = 10; 
        |---------------|
        |               |
        |               |
        |               |
        |               |
        |---------------|
        |               |
    area|  随机*随机*pi  |
        |               |
        |---------------|
    pi  |               |
        |---------------|
    r   |   10          |
        |---------------|