1.构造函数
作用:初始化对象的内存空间
class CGoods
{
public:
//构造函数(无返回值)
CGoods(char *name, float price, int amount)
{
//字符串初始化时要开辟新的内存(new),在用strcpy函数赋值
//+1('\0')
mname = new char[strlen(name) + 1]();
strcpy (mnane , name);
mprice = price;
mamount = amount;
}
private:
char *mname;
float mprice;
int mamount;
};
几个小点:
1.this指针
类型:类名* const this
调用时:将对象的地址传递给this指针,相当于this指针等于对象的内存
2.构造析构顺序
因为在栈上,所以符合先进后出(先析构的,够构造,后构造的,先析构)
3.构造函数与析构函数能不能重载
1.构造函数 可以重载
2.析构函数 不可以重载
原因:(资源被同一释放,所以不存在重载)
4.构造函数与析构函数能不能自己调用
1.构造函数。 不可以
原因:(依赖对象调用,构造函数完成后)
2.析构函数。 可以(不建议自己调用)
原因:(析构函数调用前 存在)
调用完成之后:退化成一个普通成员的方法,系统还会再次调用析构函数
5.默认的构造函数与析构函数
1.默认构造函数 不做为
类名()
{
}
2.默认析构函数 不做为
~类名()
{
}
3.默认构造函数的调用方式
类名 对象;//调用默认构造函数
类名 对象();//函数声明
2.析构函数
作用:释放对象所占资源
栈上: 系统开辟。释放
堆上: 用户开辟。释放
class CGoods
{
public:
//析构函数
~CGoods()
{
//释放堆资源
//因为是数组类型申请空间,所以释放也是数组类型
delete[] mname;
//防止野指针出现
mname = NULL;
}
private:
char *mname;
float price;
int mamount;
};
int main()
{
//生成一对象
CGoods good1("good1",1000,20);
return 0;
}
1.对象生成。 2.对象销毁
1.对象开辟内存(栈上) 1.调用析构函数(堆资源释放)
2.调用构造函数 系统。 2.释放对象所占内存(栈空间释放 )
3.拷贝构造函数
1.作用 :拿一个已经存在的对象来生成一个相同类型的新对象
2.形参必须用引用,防止形参对象构造递归构造
//浅拷贝
CGoods(const Goods& rhs)
{
mnanme = rhs.mname;
mprice = rhs.mprice;
mamount = rhs.mamount;
}
示意图:
//深拷贝
CGoods(const CGoods& rhs)
{
name = new char[strlen(rhs.mname)+1]();
strcpy(mane,rhs.mname);
price = rhs.mprice;
mamount = rhs.mamount;
}
int main()
{
CGoods good1("good1",20.1f,10);
CGoods good2 = good1;
return 0;
}
示意图:
good2先析构,释放good2,good1堆内存依然存在,所以无影响。
4.赋值运算符的重载函数
1.作用:拿一个已经存在的对象来给另外一个已经存在的对象赋值
2.系统给定的赋值运算符重载函数(类类型的引用)
//浅拷贝
CGoods& operator =(const CGoods& rhs)
{
if (this == &rhs)
{
return *this;
}
mname = rhs.mname;
mprice = rhs.mprice;
mamount = rhs.mamount;
return *this;
}
//深拷贝
CGoods& operator =(const CGoods& rhs)
{
if (this == &rhs)
{
delete[]name;
mname = new char[strlen(rhs.manme)+1];
strcpy(mname,rhs.mname);
mprice = rhs.mprice;
mamount = rhs;
}
}
int main()
{
CGoods good3;
good3 = good2;
}