#include
#include
#include
using namespace std;
class Boy {
public:
Boy(const char* pStr, int age) :age(age){
str = new char[strlen(pStr) + 1];
strcpy_s(str,strlen(pStr)+1, pStr);
}
void print() {
cout << str << "\t" << age << endl;
}
~Boy();
protected:
char* str;
int age;
};
Boy::~Boy() {
cout << "析构函数" << endl;
delete[] str;
}
int main() {
{
Boy boy1("男孩", 21);//会调用析构函数
}
cout << "程序结束"<
构造函数
构造函数基本形式
函数名和类名相同,没有返回值。
void print()的返回值是void(空)
如果不写构造函数每个类中默认有一个构造函数。
当自己写了构造函数是,默认构造函数自动删除。
构造函数无需手动调用,在构造对象的时候自动调用。
作用:构造对象(初始化数据成员)
构造函数重载(构造函数缺省)是为了构造不同长相的对象
为了更方便的构造不同对象,通常对构造函数缺省处理。
委托构造:允许构造函数调用另一个构造函数,只是要用初始化参数列表写法。
初始化参数列表(只有构造函数有)
构造函数名(参数一,参数二,。。。);成员一(参数一),成员二(参数二)。。。。{}
避免形参名和数据成员名相同而导致问题。
#include
using namespace std;
class Boy {
public:
Boy(string boyname, int boyage) {
name = boyname;
age = boyage;
}
//Boy(){}
Boy() = default;//使用系统默认无参构造函数;
void print() {
cout << name << "\t" << age << endl;
}
protected:
string name = "帅哥";
int age = 21;
};
class baby {
public:
baby(string nName="", int nAge=21) {
name = nName;
age = nAge;
}
protected:
string name;
int age;
};
//初始化参数列表
string childName = "xiaoli";
class child {
public:
child(string mname="", int mage=21) :name(mname), age(mage) {
cout << "初始化参数列表" << endl;
//继承和类的组合必须采用初始化参数列表
}
child(int mage):name(childName),age(mage){}//用全局变量来赋值也可以;
protected:
string name;
int age;
};
class man {
public:
man(string name,int age):name(name),age(age){}
man() :man("默认",18) {}//调用上面的构造函数对数据初始化;委托构造
void print() {
cout << name << "\t" << age << endl;
}
protected:
string name;
int age;
};
int main() {
//Boy littleBoy;不能构造无参的了
Boy littleBoy("boy1", 28);
littleBoy.print();
Boy littleBoy1;
baby baby1;
baby baby2("小可爱");
baby baby3("大可爱", 8);
man man1;
man1.print();
return 0;
}
析构函数
形式:
1.无返回值
2.无参数
3.函数名:~类名
不写的话也会存在一个默认的析构函数;
析构函数不需要自己调用,对象死亡之前会调用析构函数
析构函数作用:(什么时候需要手动写析构函数)
当类中数据成员是指针,并且动态申请了内存需要写析构函数
用来释放数据成员申请的动态内存(堆区内存)
new一个对象的时候,只有delete才会调用析构。
拷贝构造函数:
拷贝构造函数也是构造函数,形式是一样的,只是参数是固定的,唯一的参数是对对象的引用。
不写拷贝构造函数也存在一个默认的;
作用:通过一个对象去初始化另一个对象
什么时候调用拷贝构造:
当通过一个对象去创建出另一个新对象的时候需要;
拷贝构造什么时候需要const修饰:
当存在匿名对象赋值操作的时候,必须要const修饰
深浅拷贝
浅拷贝:默认拷贝都是浅拷贝,会引发析构问题。
深拷贝:在拷贝构造函数中做了动态内存申请(把值拷贝到一个新的内存中去)
#include
#include
#include
using namespace std;
class MM
{
public:
MM(const char* mname, int age) :age(age)
{
name = new char[strlen(mname) + 1];
strcpy_s(name, strlen(mname) + 1, mname);
}
void print()
{
cout << name << "\t" << age << endl;
}
MM(const MM& object)
{
//name = object.name;
name = new char[strlen(object.name) + 1];
strcpy_s(name, strlen(object.name) + 1, object.name);
//name = object.name;
age = object.age;
}
~MM()
{
delete[] name;
}
protected:
char* name;
int age;
};
int main()
{
{
MM mm("baby", 19);
MM girl(mm);
MM gm = mm;
mm.print();
girl.print();
gm.print();
}
return 0;
}
构造顺序和析构顺序
普通对象,构造顺序与析构顺序相反
new出来的对象,delete会直接调用析构
static对象,最后释放,程序关闭的时候生命周期才结束
#include
#include
using namespace std;
class MM
{
public:
MM(string name="x") :name(name) {
cout << name;
}
~MM(){
cout << name;
}
protected:
string name;
};
int main()
{
{
MM mm1("A"); //A
static MM mm2("B"); //B 程序关闭时候才死亡,最后析构
MM* p3 = new MM("C"); //C
MM mm4[4]; //xxxx
delete p3; //C delete 直接调用析构
p3 = nullptr;
//xxxxAB
}
//ABCxxxxCxxxxAB
return 0;
}
c++结构体
#include
#include
using namespace std;
struct MM
{
//默认为公有属性
//类中默认属性是私有属性
//protected:
string name;
int age;
public:
MM(string name) :name(name)
{
cout << "构造函数" << endl;
}
MM(const MM& object)
{
name = object.name;
age = object.age;
cout << "拷贝构造" << endl;
}
~MM()
{
}
};
int main()
{
//采用创建时候赋值的方式,也是调用构造函数
//MM object = { "lisa",19 }; 错误,因为没有两个参数的构造函数
MM object = { "lisa" };
cout << object.name << "\t" << object.age << endl;
//C++结构体一旦写了构造函数,就必须按照C++类的方式的去用
MM mm(object);
cout << mm.name << "\t" << mm.age << endl;
return 0;
}