类和对象

这是C++这样的面向对象的语言具有的特性，相较于C语言来说，更加方便的去编写代码，调用代码。

当需要大量重复的调用同一个函数的时候，我们每创建一个函数，就会建立一个栈帧，这样对于空间来讲不友好，C语言中有宏函数这样的函数，来解决这一问题，下面是宏函数的特点与样例

---

面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程，比如说，完成送外卖，C语言的处理方式为，接单，然后做菜，之后打包，最后给骑手，再到客户手里面，是针对这一过程进行分析的，也就是说，C语言这样的面向过程的语言，分析出求解问题的步骤，通过函数调用逐步解决问题

C++语言是基于面向对象的，关注的就不再是流程，而是说，关注对象，就以上文外卖问题为例，面向对象的时候，关注的就是三个对象，商家，骑手，客户，是针对于这三个对象来进行处理问题，而不是简单的只是分析解决这个问题的流程。总之，面向对象就是，将一件事情拆分为不同的对象，靠着对象之间的交互关系完成这个问题

类的引入

C++是基于c语言的，c语言中是没有对象的，我们C++就是对于C语言为基础衍生出对象这一概念，既然有了对象概念，随后伴生出了类这一个概念，类一般理解为class，当然也有struct顾名思义，就是将一些系列相关的内容放在这一类域中，这个类就是一个独立的对象

Struct（类）

接下来我们先重新认识一下struct（c++中），c++的struct，不仅仅可以作为结构体，也是可以作为类存在的，C语言的struct里面只能是变量，但是c++中可以存放变量和函数方法

//最为简单的是在C++发展之初的时，c++之父最先定义了struct为类，默认的类型（访问限定符）为public
struct Node{
    int data;
    int*next;//这就是一个简单的类
    int add(int x,int y){
        return x+y;//表示struct中是可以定义函数的
    }
}; //有一个分号

Class（类）

class是c++最为常用的表示类的方式，c++创始人在使用struct之后发现，这个struct不是很好，所以推出了class这一个表示为类的关键字。

//class是一个表示类的关键字，与struct唯一不同的是，class默认的限定操作符为private（私有的），这样的话，是不能从外界访问到class里面的函数
#incldue<iostream>
using namespace std;//c++标准库展开
class Name{
    //默认为pravite（私有），在其他Name这个类域之外是无法访问的
    //在这个域名内是可以访问的
public:
 		int data;
    	int capacity;//这样是可以访问的（在其他域中）
private:
    	int a;//（Name域之外无法访问）
};//不要忘了最后的分号，这是沿用struct的格式
int main()
{
    Name name;
    name.data//这样是可以调用的
    name.a//无法访问
    return 0;
}

因为class是为了完善struct之后出现的，所以一般来说对于类名的关键字的选择，一般选择class

类的定义

类由成员函数和成员变量组成，成员变量就是所谓的int，double等等数据类型定义的变量，也可以叫做类的属性，成员函数顾名思义就是定义在类中的函数，也可以叫做类的方法

class classname{
	//类体：也就是成员变量和成员函数存放的位置
};//这个分号是一定要有的

以上：class为类关键字，classname是类名，{}表示的是类体，也就是类的主体，需要注意的是类定义结束之后后面的分号是一定要加上的，不能省略。

类体中的内容分为：成员变量和成员函数，上文已经解释清楚

类的两种定义方式：

1. 声明和定义都放在类体中，也就是说，在类中就直接定义函数，没有分离，这样的话，编译器可能会将函数当成内联函数来处理。这个基于编译器来处理。
2. 如果说声明和定义分离的话，在类中声明，放在头文件.h中，成员函数定义在.c中，需要使用::（作用域）来定义这个函数，调用这个函数的时候，需要在成员函数名之前加上类名::

第一种

//第一种 声明和定义都在类中
class Person{
  public:
  		void info()
        {
            cout<<_name<<" "<<_age<<endl;//这就是声明和定义都在一起
        }
  private:
    	int _name;
    	int _age;//一般会使用下划线来定义变量
};
int main()
{
    Person p;
    p.info();//可以直接调用
    return 0;
}

第二种

//比如   我们要知道的一个事情是，在这个大括号内是一个域，在这个外面就是全局域，或者其他域
class Node{
public:
 	void add(int x,int y);//声明和定义分离
private:
 	int data;   
};
//进行定义
int Node::add(int& x,int& y){  //使用作用域符::
    return x+y;
}
int main()
{
    Node node;
    node.add(10,20);
    return 0;
}

目前在学习期间是比较喜欢使用第一种的，在类中直接定义函数，但是由于一些函数如果是太长的话，编译器可能会使得他称为内联函数，所以我们以后对于函数定义尽量使用第二种，只是在类中声明函数，在类外面用类名::+函数名的方式来定义函数

成员变量的命名规则：

//命名规则
class Person{
  public:
    	void getName(int name)
        {
            _name=name;//实际上当后面涉及到this语句的时候，就更好理解了，后面就可以使用this.name=name   也就是形参name赋值给类中的成员变量name
        }
  private:
    	int _name;//目前尽量保持，定义成员变量的时候，使用下划线+单词的模式
};

类的访问限定符和封装

访问限定符

C++中访问限定符分为三种：public（公有），private（私有），protected（保护），我们先认识一下封装，封装：是面向对象的三大特征之一，其实现方式为：用类将对象的成员变量和函数结合在一起，让对象更加完善，然后通过访问限定符的不同，选择性的将其接口提供给外部用户使用

//说白了，封装就是，将所有东西放在一个类里面，外界如果需要使用类中的函数或者是成员变量，这个时候就需要观察变量和函数的访问限定符
//如果是public  那么是共有的 private是私有的  protected是写保护的
class Person{
  public:			//Person类域
    int add(int x,int y) return x+y;
  private:
    int _data;//
  protected:
    int _name;
};
int main()
{				//局部域
    Person p:
    p.add(10,20);//这个是可以调用的，因为add函数是public
    p._data;//这是报错的，private的，是私有的，不能调用 
    p._name;//写保护  protected的，也是报错，不能访问，在不涉及后面知识的情况下，目前认为只有public能被外界直接访问
    return 0;
}

访问限定符说明

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外是不能直接被访问的（现在两个访问限定符是类似的，后面学到继承的时候就有区别了）；
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止，class类体默认为private，struct默认为public
4. 如果后面没有访问限定符，作用域就到 } 即类结束。所以一个{}就是一个类域
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

面试题

​ C++中struct和class的区别是什么？

解答：C++中struct和class的目前的区别，都是表示类的关键字，只需要认识到前者是默认访问限定符为public，因为要向下兼容C语言的结构体，后者是默认访问限定符为private。在C中struct只能作为结构体，存放变量，在C++中可以存放成员变量和成员函数

注意：在继承和模板参数列表位置，struct和class也有区别，后序给大家介绍。

封装

面向对象的三大特性：封装、继承、多态。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本身就是一种管理，让用户更加方便使用类

//比如说，我这个Person类中有很多变量和成员方法，但是呢，你不需要去管这个到底是什么，使用的时候只需要根据，Person的对象直接调用即可，也就是隐藏对象的属性和实现细节，仅仅是对外公开接口与对象进行交互
class Person{
  public:
    	void getName(){
            cout<<_name<<" "<<endl;
        }
  		void setName(string name){
            this._name=name;
        }
  private:
    	int _name;
    	int	_age;
};

int main()
{
    Person p;
    p.setName("why");//这样即可调用这个方法
    return 0;
}

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。（由不同访问权限符来控制）

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用::作用域操作符指明成员属于哪一个类域

//直代码演示即可，这个可以直接理解
class Person{
 public:
    int add(int x,int y);
 private:
    int data;
};
//在类体外定义成员时，需要使用::作用域操作符指明成员属于哪一个类域
//实际上就是类中定义和声明分离的时候，使用::
int Person::add(int x,int y){
    return x+y;
}//表示这个add方法是Person类域中的声明

类的实例化

用类型创建对象的过程，称为类的实例化。

1.类是对对象进行描述的，定义一个类并没有分配对应的内容空间癞存储它。
2.一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类的成员变量

#include<iostream>
class Person{
  int data;
  int Add(int x,int y){
      return x+y;
  }
};
int main()
{
    Person p;
	cout<<sizeof(p)<<" "<<endl;  
    //但是不能这样
    Person.Add(10,20);//这样会报错，目前学习阶段，因为Person没有实例化（创建对象），就没有实际的物理空间，所以不能直接来调用Add方法
    return 0;
}

进行描述的，定义一个类并没有分配对应的内容空间癞存储它。 2.一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类的成员变量`

#include<iostream>
class Person{
  int data;
  int Add(int x,int y){
      return x+y;
  }
};
int main()
{
    Person p;
	cout<<sizeof(p)<<" "<<endl;  
    //但是不能这样
    Person.Add(10,20);//这样会报错，目前学习阶段，因为Person没有实例化（创建对象），就没有实际的物理空间，所以不能直接来调用Add方法
    return 0;
}

实际上，类好比一个房子，但是如果想要房子里的物品，就需要一个钥匙p，这就是房子实例化产生的对象，为吗就可以通过钥匙p来访问房子里面的东西。