- 构造函数
- 拷贝构造函数
- 运算符
- 运算符重载
- 赋值运算符重载
- 析构函数
系统在没有构造函数时,会生成一个"合成的默认构造函数",这个能干的事情很简单,合成默认构造函数无法正确的处理很多成员变量初始化问题;
例如一个类中包含一个其他类类型的成员变量,而这个其他类中存在位移的构造函数并且是带单参数的,那么编译器就无法初始化该成员变量,所以必须定义自己的构造函数
示例:
合成默认构造函数不行的情况,One中没有自定义构造.
class Other
{
public:
Other(int) {}; //带参自定义构造
};
class One
{
public:
//这里假设不给One设置构造,使用系统默认构造,显然是不行的
Other o1;//其他类
};
int main()
{
//One test1; //这里会报错,合成构造函数无法构造成员变量o1,因为o1需要为Other的构造提供一个int参数
//vs报错信息--"不具备相应的 默认构造函数 或重载解决不明确，因此已隐式删除函数"
return 0;
}
如下,One中添加自定义构造,给初始化列表中的成员变量o1的创建提供一个实参即可:
class Other
{
public:
Other(int) {};
};
class One
{
public:
One(); //自定义构造
Other o1; //其他类
};
One::One() : o1(123) //这里用初始化列表进行初始化操作
{
}
int main()
{
One test1;
return 0;
}
一旦自己写了一个构造函数,不管这个构造函数带几个参数,系统都不会为我们创建"合成的默认构造函数".
拷贝构造函数待补充…
运算符判断大小关系,算数运算符,输入输出,赋值等
==,>=,!=,<<,>>,=,++,–等等.
一般两个整数进行比较时,例如:
int a=2,b=5;
if(a == b){...}
但是,若果两个对象进行比较时,系统就会报错, 系统通过"=="判断,到底要比什么,比较成员变量?那假如成员变量是指针类型的,那又改怎么判断是否相等?
所以这里我们就需要运算符重载,可以理解为让程序员来写比较规则,返回true或false.
运算符重载用法:
//声明
bool operator == (类名& t);
//实现 -- 重载"=="运算符
bool 类名::operator==(类名&t)//当执行if(类对象1==类对象2)时会被自动调用
{
... //规则自定义
if ... return true;
return false;
}
总结:
事实上operator==其实是一个成员函数,所以就会有返回类型和参数列表.
有些运算符,如果不自己写该运算符的重载,那么系统会自动给我们生成一个. 比如赋值运算符的重载.
示例:
#includeusing namespace std; class Time { public: Time(); Time(int hour, int min, int secs); Time(const Time&, int hour=1, int min=2, int secs=3); private: int m_Hour; int m_min; int m_secs; }; Time::Time() { m_Hour = 1; m_min = 2; m_secs = 3; cout << "调用了一次无参构造函数" << endl; } Time::Time(int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用了一次带参构造函数" << endl; } Time::Time(const Time& temp, int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用一次拷贝构造函数" << endl; } int main() { Time T1(1,2,3); //调用了一次带参构造函数 Time T2; //调用了一次无参构造函数 Time T3 = T1; //调用一次拷贝构造函数 Time T4 = { T1 }; //调用一次拷贝构造函数 Time T5; //调用了一次无参构造函数 T5 = T1; //既没调用构造,也没调用拷贝构造 return 0; }
示例中,在定义中直接给值,这个属于定义时初始化(T3,T4),而在定义中没有初始化,单独一行用等号赋值(T5),这个就属于是赋值运算符.根据打印结果也可以看出,T5没有调用拷贝构造
系统会调用拷贝赋值运算符(重载).当然,我们可以自己重载赋值运算符,正如前面提到,如果自己不重载,系统会自动给我们生成一个.
系统生成的赋值运算符重载比较简单,一般就是将非static成员的赋值给赋值运算符左侧的对象的对应成员中去.
接着上面的代码,添加赋值运算符重载
#includeusing namespace std; class Time { public: Time(); Time(int hour, int min, int secs); Time(const Time&, int hour=1, int min=2, int secs=3); Time& operator=(const Time&); //赋值重载必须定义在public中系统才能调用. private: int m_Hour; int m_min; int m_secs; }; Time::Time() { m_Hour = 1; m_min = 2; m_secs = 3; cout << "调用了一次无参构造函数" << endl; } Time::Time(int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用了一次带参构造函数" << endl; } Time::Time(const Time& tem, int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用一次拷贝构造函数" << endl; } //赋值运算符重载 Time& Time::operator=(const Time& temp) { m_Hour = temp.m_Hour; //this->m_Hour = temp.m_Hour; m_min = temp.m_min; m_secs = temp.m_secs; cout << "调用了一次赋值(=)运算符重载" << endl; return *this;//返回对象自身 } int main() { Time T1(1,2,3); //调用了一次带参构造函数 Time T2; //调用了一次无参构造函数 Time T3 = T1; //调用一次拷贝构造函数 Time T4 = { T1 }; //调用一次拷贝构造函数 Time T5; T5 = T1; //调用了一次赋值(=)运算符重载 //T5的this对象,而=后面的参数就是T1 return 0; }
说明:
(1)示例中T5就是operator=运算符里的this对象,T1就是operator=里面的形参.
(2)operator=运算符的返回值通常是一个指向左侧运算符对象的引用,也就是这个T5的引用,返回的是对象自己.(return *this)
(3)如果禁止Time类型对象之间赋值,直接将运算符重载的声明用private修饰即可,如上,示例中放在了public中,系统才会调用.
注:vs快捷键shift+F9:断点时,可以查看变量详细信息;
特点:相反于构造函数;
main函数结束时,系统自动调用销毁函数,也就是析构;
如果我们不写析构,系统也会给一个默认的析构函数,默认析构函数的函数体为空
析构函数不会释放new的内存,所以这时候需要手动写析构释放内存(delete);
写法
~类名(); //没有返回值,不接受任何参数,不能被重载,一个类只能有一个析构; //示例 ~Time();
注意:没有返回值,不接受任何参数,不能被重载,一个类只能有一个析构,不存在重载函数,因为没参数;
示例
注:此示例包含构造/拷贝构造/赋值运算符重载/析构函数,接着上个例子补充
#includeusing namespace std; class Time { public: Time(); ~Time(); Time(int hour, int min, int secs); Time(const Time&, int hour=1, int min=2, int secs=3); Time& operator=(const Time&); //赋值重载必须定义在public中系统才能调用. private: int m_Hour; int m_min; int m_secs; }; Time::Time() { m_Hour = 1; m_min = 2; m_secs = 3; cout << "调用了一次无参构造函数" << endl; } Time::~Time() { cout << "调用了一次析构函数" << endl; } Time::Time(int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用了一次带参构造函数" << endl; } Time::Time(const Time& tem, int hour, int min, int secs) { m_Hour = hour; m_min = min; m_secs = secs; cout << "调用一次拷贝构造函数" << endl; } Time& Time::operator=(const Time& temp) { m_Hour = temp.m_Hour; //this->m_Hour = temp.m_Hour; m_min = temp.m_min; m_secs = temp.m_secs; cout << "调用了一次赋值(=)运算符重载" << endl; return *this;//返回对象自身 } int main() { Time T1(1,2,3); Time T2; Time T3 = T1; Time T4 = { T1 }; Time T5; T5 = T1; //T5的this对象,而=后面的参数就是T1 return 0; }
调用了五次析构函数,main函数执行完之后,释放局部的T1,T2…对象时系统都会调用自己写的析构函数;
注:析构函数的销毁是析构函数执行之后,而不是在这个函数体内,函数体内主要是一些自定义的delete.
Time::Time()
{
p = new char[100];
}
Time::~Time()
{
delete[] p;//这里一定要自己释放,系统是不会释放new.
}
