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          |
|---------------|