实例化对象：

意味着一定有调用构造函数 

实例化就是给，数据成员分配内存，构造对象。对象的成员函数和普通函数的区别就是，成员函数有个指向当前对象的this指针，可以访问对象的成员变量，其依赖于对象。静态函数就更像一个全局函数，没有this指针，可以通过类名直接访问，可以被对象的成员函数访问，静态函数只能访问类的静态成员。这些可访问属性是由编译器来实现的，编译之后就没有对象、成员这些东西了，都是数据和方法。

一.在栈区实例化对象

1.调用无参构造函数实例化对象   类型名 ---  class/struct类型
	类型名 对象名;
	类型名 标识符();   //函数声明   不是实例化对象
	类型名();         //匿名对象
2.调用有参构造函数
	类型名 对象名(实参列表);
	类型名(实参列表);   //匿名对象

#include <iostream>
#include <string>
using namespace std;

class stu
{
private:
	//成员属性
	int no;
	string name;
	int score[3];
public:
	//构造函数  默认的无参构造函数 默认的无参构造编译会自动提供	
	stu()
	{
		cout << "无参的构造函数: " << endl;
	}	
	//用于给成员属性初始化
	void init(int ino,string iname,int iscore[3])
	{
		no = ino;
		name = iname;
		for(int i = 0;i< 3;i++)
			score[i] = iscore[i];
	}	
	void show()
	{
		cout << "学号: " << no << "姓名: " << name << "成绩: ";
		for(int i = 0;i<3;i++)
			cout << score[i] << " ";
		cout << endl;	
	}
};



int main()
{
	stu s;//实例化一个对象
	//调用一下init和show方法
	int score[3] = {88,65,95};
	s.init(110,"马化",score);
	s.show();
	stu s1(120,"马云",score); //实例化对象 调用构造函数 传递三个参数
	s1.show(); 
	return 0;
}

匿名对象：

	没有名字的对象，直接用类型名(实参列表);来构造
	经常在函数中会返回匿名对象  或者 在调用函数时 传递匿名对象
	往往会直接用变量(形参)去接收匿名对象  
	这个过程会进行优化 直接让变量"引用"该匿名对象
		如果不优化:1.调用拷贝构造  2.调用拷贝赋值函数    拷贝过程
	类型名 对象名 = 匿名对象;//优化

生命周期：

class Cat
{
public:
    Cat()
    {
        cout<<"Cat类 无参构造函数"<<endl;
    }

    Cat(Const Cat& obj)
    {
        cout<<"Cat类 拷贝构造函数"<<endl;
    }

    ~Cat()
    {
        cout<<"Cat类 析构函数 "<<endl;
    }

};

void playStage() //一个舞台，展示对象的生命周期
{
    Cat();             /*在执行此代码时，利用无参构造函数生成了一个匿名Cat类对象；执行完此行代码， 因为外部没有接此匿名对象的变量，此匿名又被析构了*/
    Cat cc = Cat();    /*在执行此代码时，利用无参构造函数生成了一个匿名Cat类对象；然后将此匿名变 成了cc这个实例对象，此匿名对象没有被析构。*/
    cout<<"cc 对象好没有被析构"<<endl;    
}

int main()
{
    playStage();
    system("pause");
    return 0;
}

二、在堆区实例化对象
类型名 *指针变量 = new 类型;  //调用无参构造函数实例化对象
类型名 *指针变量 = new 类型();//调用无参构造函数实例化对象
类型名 *指针变量 = new 类型名(实参列表); //调用有参构造函数

#include <iostream>
#include <string>
using namespace std;


class yg
{
private:
	int no;
	string name;
	string departname;
	float money;	

public:
	
	yg(int ino,string iname,string idepartname,float imoney)
	{
		cout << "四个参数的构造函数" << endl;
		no = ino;
		name = iname;
		departname = idepartname;
		money = imoney; 
	}
	//会自行添加午餐构造函数
	yg()
	{
		cout << "无参构造函数" << endl;
	}
	void show()
	{
		cout << "员工号:" << no << " 名字:" << name << " 部门名称:" << departname << " 工资:" << money << endl;
	}

};

int main()
{
	//yg s1;
	//yg s2(110,"马云","阿里巴巴",10000);
	//s2.show();	
	//emp e4 = emp(122,"马云","阿里巴巴",1.0);//右边是一个匿名对象 ,左边是一个同类型的对象
	//进行了优化 直接让e4指向匿名对象
	//emp().show;
	
	//emp *pe2 = new emp;//调用无参构造函数实例化对象
	//emp *pe3 = new emp();//调用无参构造函数实例化对象
	//delete pe2;
	//delete pe3;
	
	yg *pe2 = new yg(110,"马云","阿里巴巴",10000);
	pe2->show();
	
	return 0;
}

注意:
	类型名 *指针变量 = (类型名*)malloc(sizeof(类型名));
	没有实例化对象  没有调用构造函数   只分配了内存空间
	
普通对象访问成员属性和调用成员函数用  .
类指针访问成员属性和调用成员函数时用  ->    (*指针变量).

new 类型名(实参列表);   //匿名对象  无法delete内存

数组对象:
	定义类类型成员的数组
	类型名 数组名[数组长度]；  //调用类型的无参构造函数
	类型名 数组名[数组长度] = {类型(实参列表),...}；
	
	类型名 *指针 = (类型*)malloc(sizeof(类型)*len); //只分配内存 不会调用构造函数
	类型名 *指针 = new 类型[数组长度]； //调用无参构造函数