0708学习总结(构造函数，析构函数，关键字)

一.面向对象的特征：封装，继承，多态


二.类是一种声明，不占内存
两种创建对象的方式：
1.一种是在栈上创建，形式和定义普通变量类似；
2.一种是在堆上创建，必须要用一个指针指向它。Delete释放到不再使用的对象。


三.申请空间使用类成员
1.student *stu = new student;
stu-> ....
delete stu;

2.student *stu = new student[10];
stu[0]. ...
stu[1]. ...
delete[] stu;

3.student stu1;
 student *pstu = &stu1;
pstu-> ...
注：
类定义时，不能对成员变量赋值

四.在类内声明，在类外定义
注：在类的内部，三种权限可以互相访问
代码：
#include <iostream>
using namespace std;


class student
{
private: //私有
char *m_name;
int m_age;
float m_score;


public://公有
void name(char *name);
void age(int age);
void score(float score);
void print();
};


void student::name(char *name)
{
m_name  = name;
}
a
oid student::age(int age)
{
m_age = age;
}
void student::score(float score)
{
m_score = score;
}


void student::print()
{
cout<<m_name<<" "<<m_age <<" "<<m_score<<endl;
}


int main()
{
student stu;
stu.name("xiaoming");
stu.age(20);
stu.score(98.9);
stu.print();


return 0;
}
四.构造函数
1.名字和类相同
2.无返回值
3.不需要显示调用
4.创建对象时自动执行

注：构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。

例子：
#include <iostream>
using namespace std;


class student
{
private:
char *m_name;
int m_age;
float m_score;


public:
student(char *name,int age,float score);
void print();
};


student::student(char *name,int age,float score)
{
m_name = name;
m_age = age;
m_score = score;
}


void student::print()
{
cout<<m_name<<","<<m_age<<","<<m_score<<endl;
}


int main()
{
student stu("xiaoming",20,89.9);
stu.print();
cout<<"sizeof stu"<<sizeof(stu)<<endl;


student *stu1 = new student("xiaoming",20,89.9);
stu1->print();
cout<<"sizeof stu1"<<sizeof(*stu1)<<endl;//不加*是14

delete stu1;

return 0;
}
注：1.函数在代码区分配内存
2.成员对象在栈上，堆上分配内存

构造函数的重载：
1.构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；
    2.反过来说，创建对象时只有一个构造函数会被调用

五.初始化成员列表
例：
student::student(char *name,int age,float score):m_name(name),m_age(age),m_score(score){}
注：与成员在类中的声明的顺序有关
六.析构函数
1.无返回值
2.不要显示调用
3.程序销毁时自动执行
例：
#include <iostream>
using namespace std;


class area
{
private:
int *length;
int *width;


public:
area(int a,int b);
~area();//析构函数
void print();
};
area::area(int a,int b)
{
length = new int;
width = new int;
*length = a;
*width = b;
}


area::~area()
{
delete length;
delete width;
}


void area::print()
{
cout<<*length<<endl;
cout<<*width<<endl;
cout<<(*length)*(*width)<<endl;
}


int main()
{
area stu(4,5);
stu.print();
}

注意：
1.析构函数没有参数，不能被重载，因此一个类只能有一个析构函数。
2.如果用户没有定义，编译器会自动生成一个默认的析构函数

析构函数执行时机：
1.在所有函数之外创建的对象是全局对象，它和全局变量类似，位于内存分区中的全局数据区，程序在结束执行时会调用这些对象的析构函数。
2.在函数内部创建的对象是局部对象，它和局部变量类似，位于栈区，函数执行结束时会调用这些对象的析构函数

七.const
1.初始化const成员变量：
2.参数初始化表还有一个很重要的作用，那就是初始化 const 成员变量。
3.初始化 const 成员变量的唯一方法就是使用参数初始化表

八.this指针
this 是 C++ 中的一个关键字，也是一个 const 指针，它指向当前对象，通过它可以访问当前对象的所有成员。
所谓当前对象，是指正在使用的对象。

注意：
1.this 只能用在类的内部，通过 this 可以访问类的所有成员，包括 private、protected、public 属性的。
2.this 是一个指针，要用->来访问成员变量或成员函数。
3.this 是 const 指针，它的值是不能被修改的，一切企图修改该指针的操作，如赋值、递增、递减等都是不允许的。
4.this 只能在成员函数内部使用，用在其他地方没有意义，也是非法的。
只有当对象被创建后 this 才有意义，因此不能在 static 成员函数中使用（后续会讲到 static 成员）


This是什么？

1.this 实际上是成员函数的一个形参，在调用成员函数时将对象的地址作为实参传递给 this。
2.不过 this 这个形参是隐式的，它并不出现在代码中，而是在编译阶段由编译器默默地将它添加到参数列表中。
3.this 作为隐式形参，本质上是成员函数的局部变量，所以只能用在成员函数的内部，并且只有在通过对象调用成员函数时才给 this 赋值


九.static成员变量
在C++中，我们可以使用静态成员变量来实现多个对象共享数据的目标。
静态成员变量是一种特殊的成员变量，它被关键字static修饰，


static 成员变量属于类，不属于某个具体的对象，即使创建多个对象，也只为 m_total 分配一份内存，所有对象使用的都是这份内存中的数据。
当某个对象修改了 m_total，也会影响到其他对象。
注意：
static 成员变量必须在类声明的外部初始化，具体形式为：     type   class::name = value;

静态成员变量在初始化时不能再加 static，但必须要有数据类型。
被 private、protected、public 修饰的静态成员变量都可以用这种方式初始化。


注意：static 成员变量的内存既不是在声明类时分配，也不是在创建对象时分配，而是在（类外）初始化时分配。

反过来说，*没有在类外初始化的 static 成员变量不能使用