【C++】类与对象（上）

//C语言中
struct Stack
{
      DataType* _array;
      size_t _capacity;
      size_t _size;
}

  void func()  {;}
  ......

//C++中

struct Stack
{
    //成员函数
   void Init(size_t capacity)
  {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
      if (nullptr == _array)
    {
     perror("malloc申请空间失败");
      return;
     }
     _capacity = capacity;
      _size = 0;
  }


    void Push(const DataType& data)
  {
    _array[_size] = data;
    ++_size;
  }
   ..........

    //成员变量
    DataType* _array;
      size_t _capacity;
      size_t _size;
}

这就是类和对象的优点，它不仅拥有C语言中struct的所有用法，还在其基础上增加了类和对象。

不仅可以定义变量，还可以定义函数！

类的定义：

class className

{

     // 类体：由  成员函数  和  成员变量 组成

};   // 一定要注意后面的分号

  

class 为 定义类的 关键字（相当于把struct换成了class）， ClassName 为类的名字， {} 中为类的主体，注意 类定义结束时后面 分 号不能省略 。

类体中内容称为 类的成员： 类中的 变量 称为 类的属性 或 成员变量 ; 类中的 函数 称为 类的方法 或者 成员函数 。

即  类=成员函数+成员变量，成员函数就是方法，成员变量就是属性！

三、类的使用，成员的声明和定义

1.类的使用

class Stack // 类型
{

	void Push(int x)
	{
		// Init();
		//...
	}

	void Init(int N = 4)
	{
		// ...
		top = 0;
		capacity = 0;
	}


	int* a;  
	int top;
	int capacity;
};

上面代码我们定义了一个类，但我们可以这样使用吗?

Stack.a=NULL;

Stack.top=0;

当然不行！！

若我们使用struct这样使用的话，就会发现：

struct Stack // 类型
{

	int* a;  
	int top;         //声明
	int capacity;
};

Stack.a=NULL;

Stack.top=0;     这样使用当然不行，struct只是一张图纸，只是声明，声明不会开辟内存空间，只有定义该变量以后Stack s;(定义），才可以使用。

C语言中，Stack s，s叫做变量,但在C++中，s就是对象。

所以回顾以后，我们应该先定义一个对象,通过对象去访问里面的值。

Stack s；

s.a=NULL;

s.top=0; 

2.成员的声明与定义的使用

struct Stack
{
    //成员函数
   void Init(size_t capacity)
  {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
      ...
     _capacity = capacity;
      _size = 0;
  }
     ......
    //成员变量
    DataType* _array;
      size_t _capacity;
      size_t _size;
}

struct Stack
{
    //成员函数
   void Init(size_t capacity);
     ......
    //成员变量
    DataType* _array;
      size_t _capacity;
      size_t _size;
}

   void  Stack:: Init(size_t capacity)
  {
     _array = (DataType*)malloc(sizeof(DataType) * capacity);
      ...
     _capacity = capacity;
      _size = 0;
  }

四、类的访问限定符及封装

1.访问限定符

当然，在类中呢，C++还提出了一些其他的东西，public和private：

class Stack // 类型
{
public:
	void Push(int x)
	{
		// Init();
		//...
	}

	void Init(int N = 4) //缺省参数
	{
		// ...
		top = 0;
		capacity = 0;
	}

private:
	int* a;  
	int top;
	int capacity;
};

C++ 实现封装的方式： 用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选 择性的将其接口提供给外部的用户使用 。

【访问限定符说明】

1. public 修饰的成员在类外可以直接被访问

2. protected 和 private 修饰的成员在类外不能直接被访问 ( 此处 protected 和 private 是类似的)

3. 访问权限 作用域从该  访问限定符  出现的位置开始直到下一个访问限定符出现时为止

class Stack // 类型
{
public:
    void Push(int x)
    {
        // Init();
        //...
    }

    void Init(int N = 4)
    {
        // ...
        top = 0;
        capacity = 0;
    }
//private:
    int* a;
    int top;
    int capacity;
};

若有private，则public的作用域到private，private的作用域到结尾。

若没有，则直接到结尾，整个都为公开public。

5. class 的默认访问权限为 private ， struct 为 public( 因为 struct 要兼容 C)

    这就是为什么，struct中，变量访问结构体中的值，可以随便访问。

2.封装

面向对象的三大特性：封装、继承、多态。（最重要的三个特性）

在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来

和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。 一种管理方式。

举例说明：

在C语言中，实现栈时，大家如果都很遵循规则，访问栈顶元素时，就会调用Top函数，但是总会有人直接去 打印st.a[top]，但是可能此时的top不一定是栈顶，可能也是栈顶的前一个，每个人实现的方式都不同，所以就会出现问题。

但是在C++中，就体现了封装的作用，是一种管理，就会将类的成员变量设置为私有private，就不会让你去访问，只是通过函数接口来访问，这样就不会出现问题。 

 

class Person
{
public:
 void PrintPersonInfo();
private:
 char _name[20];
 char _gender[3];
 int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 cout << _name << " "<< _gender << " " << _age;
}

那就会有人想，可不可以这样使用  Person::_age = 1;不是命名空间域访问里面的变量时，就可以通过域操作符来访问吗？

但是这里是有区别的，命名空间域相当于设置了一堵围墙，他将里面的变量围了起来，只能通过域操作符来访问到里面变量，函数等，但是类的作用域（类域）它是一堵虚拟墙，他没有实体，就相当于加了密码锁的一张图纸，没有实质内容的，必须按照图纸造出对象以后，才可以通过域操作符来访问。

2.this指针的特性

1. this 指针的类型：类类型 * const ，即成员函数中，不能给 this 指针赋值。

void Print(Data* const this)
    {
        cout << this->_year << " " << this->_month << " " << this->_data << endl;
    } 

  const在*后面，限制的是指针变量，this指针不可以被修改。

 

Data const*this

const Data*this  这两都是限制的this指针指向的那个变量不能被修改