C++ 引用 到类部分

1.6引用

引用语法：Type& name = value；

1.6.1规则

1. 引用没有定义,是一种关系型声明。声明它和原有某一变量(实体)的关
   系。故 而类型与原类型保持一致,且不分配内存。与被引用的变量有相同的地
   址。

2. 声明的时候必须初始化,一经声明,不可变更。

3. 可对一个变量引用,再次引用。多次引用的结果,是某一变量具有多个别名。

4. &符号前有数据类型时,是引用。其它皆为取地址。

   int main(void)
   {
   int a, b;
   int &r = a;
   int &r = b;//错误,不可更改原有的引⽤用关系
   float&rr = b;//错误,引⽤用类型不匹配
   cout<<&a<<&r<<endl;//变量与引⽤用具有相>同的地址。
   int &ra = r;//可对引⽤用更次引⽤用,表⽰示a变量有两个别名,分别是和
   ra
   return 0;
   }

1.6.2引用的意义

1）引用作为其他变量的别名，因此在一些场合代替指针使用
2）引用较指针具有更好的可读性和实用性

1.6.3引用的空间

1）引用在C++内部的实现是一个常指针
Type&name <--------->Type* const name
2）C++编译器在编译过程中使用常指针走位引用内部的实现，因此引用所用的空间大小与指针相同。
3）使用角度会误以为引用只是一个别名，这是C++为了实用而作出的细微性隐藏。

1.6.3const引用
const 引用有较多使用。它可以防止对象的值被随意修改。因而具有一些特性。

(1)const 对象的引用必须是 const 的,将普通引用绑定到 const 对象是不合法的。这个原因比较简单。既然对象是 const 的,表示不能被修改,引用当然也不 能修改,必须使用 const 引用。实际上,
const int a=1;
int &b=a;
这种写法是不合法 的,编译不过。

(2)const 引用可使用相关类型的对象(常量,非同类型的变量或表达式)初始化。这个是 const 引用与普通引用最大的区别。
const int &a=2;
是合法的。
double x=3.14;
const int &b=a; 但是b实际上是获得了一个临时变量的地址
也是合法的。

Const 引用原理：
Const引用目的是，禁止修改引用值来改变被引用的对象。

1.6.4指针与引用

                          引用	                                           指针


 相同点：都是地址概念	    某内存的别名	                           指向一块内存的地址，内容是所指内存地址
 
 不同点：	              只是别名	                                   指针是实体
  
                       使用时一定要初始化，不能为空	               可以不用初始化，可以为空

                  引用的sizeof（）大小指的是所对应的变量的大小	   指针sizeof大小所对应的是其对应类型的大小
                  
                  对引用使用++ 等于对变量本身加一	               对指针使用++就是对其所指向的类型加一
                  
                   没有多级引用	                                有多级指针
                   
                  引用不需要解引（*）编译器会自动实现	            指针则需要解引（*）
                  
                 引用一旦使用就不能变更也就是一生一世只能对应一个变量	普通指针向一个变量时可以任意的改变
                 
                这里其实引用就是一个常指针 Type* const name  <====>  Type& name

1.7内联函数（inline）

关键字 ：inline 定义&&声明时一定不要忘了关键字

1.7.1基本概念

宏编译是预处理非常的快
宏函数的缺陷：无法解决传参的弊端
宏函数的定义：#defineMax（a,b）
宏的多次调用会引起源代码膨胀，是目标文件尺寸变大
宏函数只是简单的文本替换过程（经过预处理器处理）但是内联函数则需要编译器进行编译（编译器编后将函数体插入调用的地方）
内联函数作用与宏函数作用类似（没有压栈出栈的过程）即就是 压栈，跳转 返回（这是普通函数调用的额外开销部分）
内联函数是在函数内部 不是编译预处理，而是编译器进行的处理，编译器将内联函数的函数体直接展开
使用场景：
函数被频繁使用并且函数体积小
当一个函数被频繁使用的时候，但是当inline函数太过于复杂时编译器就会自动将其作为普通函数。

1.7.2内联函数的定义

inline void fun()
{
    …
} 

1. 内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。
2. C++编译器会直接将函数插在函数调用的地方
3. 内联函数没有普通函数调用时的额外开销（压栈，跳转，返回）
4. 内联函数是特殊函数但是它具有普通函数的特征

1.7.3内联函数使用的注意
内联函数的限制：
使用内联函数时候不存在任何形式的循环语句
不能存在过多的条件判断语句
函数体不能过于庞大
不能对其进行取址操作
内联函数的声明必须在调用之前
当inline函数太过于复杂并且执行开销远大于压栈跳转返回的开销时‘’内联函数也就没有了意义。

1.7.4内联函数小结
优点：内联函数避免了普通函数调用时的额外开销（入栈出栈操作）
本质：内联函数以牺牲代码段空间的代价，来提升运行时间的效率
缺点：由于内联函数的函数体在代码段中会出现多个“副本”,因此会增加代码
段的空间。

2.0类和对象

类 关键字 class

2.0.1类与结构体
类与结构体相似都是对编程实体属性的描述
但是类与结构体也有不同之处

                                 类                                                结构体
  关键字            class	                                                      struct
       类对类内成员访问全选的设定默认为私有 private  	                 结构体对其内部成员的设定默认是     
                                                                       public公共的      
                                                                                                                                                                                                                  
       类内可以设置实现实体功能的函数	                                 不可以

类的权限：
public（共有公开权限）外部可以访问
private（私有）只能类的内部成员使用
protect（保护）只能类的内部成员使用

使用：

class name｛
public：
       void cout_array()
{
    int i = 0;
    for(;i<10;i++)
{
    cout<<array[i]<<” ”<<endl;
}
}

//public的部分到这里就结束了 如果想要访问私有成员变量可以通过调用公共函数体方式实现调用
Private:
int array[10] = {1,23,4,5,6,7,8,9,1,0};
//私有成员一旦定义外部无法访问
｝

2.0.2类的使用

对类的定义：

class people            //定义了一个名为people的类
{
public:                 //设置访问权限为公共的 外部的文件可以访问
	char gender[64];
	void print_f()     //在类内部设置的函数  不建议这样做  这样做有可能是编译器误认为是内//联函数
	{
		cout << "性别:" << gender << "\n" << endl;
	}
	void active()
	{
		cout <<"打篮球\n" << endl;
	}
	void _active()
	{
		cout <<"跳舞\n" << endl;
	}
};//这里的分号一定要记着

对类的使用：

int main()
{
	people male;               //首先进行使用前的声明   
	strcpy(male.gender, "male");//对类内部成员的使用
	male.print_f();
	male.active();

	people female;
	strcpy(female.gender, "male");
	female.print_f();
	female._active();
	return 0;
}

面向对象和面向过程：
面向过程以函数来实现其功能

面向对象和面向过程一句话： 吃 狗翔 着重于过程也就是（吃） 面向对象 狗 吃 翔 着重于对象（狗）（翔）

再打个比方：

如果想要将大象放进冰箱：

面向过程是这样做的： 第一步：打开冰箱门；
第二步：抱起大象；
第三步：将大象塞进冰箱
第四步：关上冰箱门
面向对象是这样做的：
首先进行分类：
我 大象 冰箱
然后才是
我与冰箱发生了啥 冰箱被我打开
我与大象发生了啥 我抱起大象
大象与冰箱发生了啥 大象进入冰箱
我最后与冰箱发生了啥 我关上冰箱门