C++ 类与对象、构造函数与析构函数、this指针、static成员、const 5.27

第三天：

类与对象

1 类与对象
	  1.1 类是对象的抽象，对象是类的实例
	  class Demo 
	  {
	    public:  //公有的接口函数和数据，能够通过对象访问
		  int a1;
		  void func1()
		protected: //保护的成员数据和函数，不能通过对象访问
		  int a2;
		  void func2()
		private: //私有的成员数据和函数，不能通过对象访问
		  int a3;
		  void func3()
	  };
	  

​	  1.2 对象的定义：
​	  Demo d1(10, 20);
​	  Demo *p = new Demo(10, 20);
​	  d1.func1()
​	  p->func1()
​	  
​	  1.3 如果用户在定义自己的类的时候，没有定义自己的构造，析构，拷贝构造函数，赋值操作符，取址操作符，系统会为改类生成默认的相应的函数

构造函数与析构函数

	2 构造函数和析构函数
	  2.1 构造函数：
	    作用是初始化，分配系统资源
	    和类的名字一样    Demo()
		没有返回值
		不需要用户调用，在创建对象的时候系统自动帮你调用
		可以重载（overload）
	  2.2 初始化列表
	    Demo(int a, int b):aa(a), bb(b)
		
	  2.3 析构函数：
	    作用是在一个对象生命周期结束的时候被调用，释放系统资源，完成一些清理的工作
		和类的名字一样，前面加一个~      ~Demo（）
		没有返回值
		也不需要参数
		不需要用户主动去调用，系统在对象生命周期结束的时候被调用
		可以重写(override)
        
 /*===============================================
*   文件名称：construct.cpp
*   创 建 者：     
*   创建日期：2023年05月29日
*   描    述：
================================================*/
#include <iostream>
using namespace std;

class Demo{
    public:
    Demo(int a=101,int b=202,int c=303);//构造函数,初始化用的
    ~Demo();
    void show();
    private:
        int aa;
        int bb;
        int cc;
};

Demo::Demo(int a,int b,int c):
    aa(a),bb(b),cc(c)//初始化
{
    cout << "Demo:Demo()" <<endl;
}
/*
Demo::Demo(int a,int b,int c)
{
    cout << "Demo:Demo()" <<endl;
    aa = a;
    bb = b;
    cc = c;
}
*/
Demo::~Demo()
{
    cout << "Demo::~Demo()" << endl;
}

void Demo::show()
{
    cout << "aa=" << aa << endl;
    cout << "bb=" << bb << endl;
    cout << "cc=" << cc << endl;
}

int main()
{
    Demo();
    Demo d2;
    d2.show();
    Demo d3(1000);
    d3.show();
    Demo d4(1000,2000);
    d4.show();
    Demo d1(100,200,300);
    d1.show();
    return 0;
}

this指针

3 隐藏的this指针
  this指针是一个特殊指针，它指向类对象的首地址
  每一个类的对象都有一个自己的this指针
  this指针只能在类的内部使用
  Demo::show()   编译过后,编译器自动的增加了this指针，this指针它指向调用对象的首地址   ==》 Demo::show(Demo *this)
  当对象d1去调用show函数的时候    d1.show()   相当于 =》 d1.show(&d1);
/*===============================================
*   文件名称：this.cpp
*   创 建 者：     
*   创建日期：2023年05月29日
*   描    述：
================================================*/
#include <iostream>
using namespace std;

class Demo{
    public:
        Demo(int a):aa(a){}
        void show();
        Demo* getThis();
    private:
        int aa;
};

void Demo::show()
{
    cout << "aa=" << aa << endl; 
    cout << "aa=" << this->aa << endl; 
}

Demo* Demo::getThis()
{
    return this;
}

int main()
{
    Demo d1(100);
    d1.show();

    cout << "this = " << d1.getThis() << endl;
    cout << "&d1  = " << &d1 << endl;
    Demo d2(66);
    d2.show();
}

static成员

4 static成员
  4.1 可以将类的成员变量和成员函数申明为static,叫类的静态成员变量和静态的成员函数
  4.2 使用类名和作用域访问符来访问它
      Demo::total_num //静态的成员变量
	  Demo::show_howmany() //静态的成员函数
  4.3 静态的成员它属于类，所以它不带this指针
  
/*===============================================
 *   文件名称：static.cpp
 *   创 建 者：     
 *   创建日期：2023年05月29日
 *   描    述：
 ================================================*/
#include <iostream>
using namespace std;
class demo{
    public:
        demo(int a);
        ~demo();
        static  void howmany();
        void show2();
        void show();
    private:
        int aa;
    private:
        static int objs;
};

int demo::objs = 0;

demo::demo(int a):aa(a)
{
    objs++;
}


void demo::howmany()
{
    cout << "there are " << objs << " objects" << endl;
}

demo::~demo()
{
    objs--;
}

void demo::show()
{
    cout << "demo::show()" << endl;
}
void demo::show2()
{
    cout << "demo::show2(),aa= " << aa << endl;
}

int main()
{
    demo::howmany();
    //   demo d1(100);
    //  d1.howmany();
    // cout << demo::objs << endl;
    demo *p1 = new demo(100);
    p1->howmany();
    demo *p2 = new demo(100);
    p2->howmany();
    demo *p3 = new demo(100);
    p3->howmany();

    delete p3;
    p3->howmany();

    demo *p4 = NULL;
   // p4->howmany();//howmany是个静态函数，没有this指针
    p4->show();//
    p4->show2();//
    delete p1;
    p1->howmany();
    delete p2;
    p2->howmany();
}

const

5 const, const成员函数，const成员变量，const对象
  5.1 const变量必须初始化，并且不能被更改
  5.2 const int *p1 = &bb; //p1是指向常量的指针,指向的值不能被修改，指针本身可以修改
  5.3 int * const p2 = &bb; //p2是一个常指针,指针本身不能修改，指向的值可以修改
  5.4 const int *p3 const = &bb;//p3是一个指向常量的常指针，指针本身不能改变，指向的值也不能
  
  const成员函数
    如果需要保证成员函数不会修改对象的成员变量，可以将该函数设置为const成员函数
    void Demo::show() const;
/*===============================================
*   文件名称：const.cpp
*   创 建 者：     
*   创建日期：2023年05月29日
*   描    述：
================================================*/
#include <iostream>
using namespace std;


int main()
{
    const int aa = 100;//const 变量不能被更改
 //   aa = 101;
    int bb = 200;
    int cc = 300;

    const int *p1 = &bb;//p1是指向常量的指针,指向的值不能被修改
  //  *p1 = 400;
    bb = 344;
    p1 = &bb;
    cout << "*p1 = " << *p1 << endl;
    cc = 121;
    p1 = &cc;
    cout << "*p1 = " << *p1 << endl;
    cout << "-----------------------" << endl;

    int * const p2 = &bb;//p2是个常指针,指针本身不能修改，指向的值可以修改
    cout << " p2 = " <<  p2 << endl;
    cout << "*p2 = " <<  *p2 << endl;
    *p2 = 500;
    cout << " p2 = " <<  p2 << endl;
    cout << "*p2 = " <<  *p2 << endl;
    cout << "-----------------------" << endl;
    const int * const p3 = &bb;//p3是一个指向常量的常指针，指针本身不能改变，指向的值也不能改变
    cout << " p3 = " <<  p3 << endl;
    cout << "*p3 = " <<  *p3 << endl;

    return 0;
}