实例化对象：
意味着一定有调用构造函数
实例化就是给，数据成员分配内存，构造对象。对象的成员函数和普通函数的区别就是，成员函数有个指向当前对象的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 类型[数组长度]； //调用无参构造函数
