实例代码:
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Time2{
int aa;
int bb;
};
class Time {
private:
void initMillTime(int mls) {
Millisecond = mls;
}
int Millisecond; //毫秒
public:
int Hour; //小时
int Minute;//分钟
//int Second;//秒钟
Time2 t2;
//int Second = 0;//秒钟 类内初始化
int Second = { 0 };//秒钟 类内初始化
mutable int testVal;
char* p;
//构造函数
Time(int temphour, int tmpmin, int tmpsec){
Hour = temphour;
Minute = tmpmin;
Second = tmpsec;
initMillTime(0);
cout << "调用了构造函数Time(int temphour, int tmpmin, int tmpsec)" << endl;
}
Time(int temphour, int tmpmin){
Hour = temphour;
Minute = tmpmin;
Second = 59;
initMillTime(50);
p = new char[100];
cout << "调用了构造函数Time()" << endl;
}
Time(){
} //不加参数了
//拷贝构造函数
Time(const Time &tmptime, int a = 60){
std::cout << "调用了 Time::Time(Time &tmptime, int a) 拷贝构造函数" << std::endl;
}
// 重载的赋值运算符
Time & operator=(const Time& tmpobj){
Hour = tmpobj.Hour;
Minute = tmpobj.Minute;
Second = tmpobj.Second;
std::cout << "调用了Time &Time::operator=(const Time&) 赋值运算符重载" << std::endl;
return *this;
}
//析构函数(释放函数)
Time::~Time(){
delete[] p;
std::cout << "调用了Time::~Time()析构函数" << std::endl;
}
void addHour(int tmphour) {
Hour += tmphour;
}
void addHour1(int tmphour) const{
//Hour += tmphour; //报错 这地方不能修改成员变量的值
}
void fixVal() const {
testVal = 10;
}
//把对象自己给返回回去了
Time& add_hour(int tmphour) {
Hour += tmphour;
return *this; //把对象自己给返回去了
}
};
int main() {
// 一:重载运算符
// ==, >, >= , < , <=, != , ++, --, +=, -=, +, -, cout, cin << 和 >> ,= 赋值运算符。
int a = 4, b = 5;
if (a == b){
// ...
}
Time myTime;
Time myTime2;
//if (myTime == myTime2){
//
//}
//两个对象真的不能进行== 比较吗?,是可以比较的,我们需要 “重载 == 运算符”
// 说白了,我们要写一个成员函数,这个成员函数名 “operator==”,这个成员函数体里边 我们就要写一些比较逻辑。
if (myTime.Hour == myTime2.Hour){
return true;
}
//正式总结一下:
//重载运算符,本质上是一个函数。整个函数的正式名字 :operator 关键字接运算符。
//既然重载运算符本质上是一个函数,那么会有返回类型和参数列表。
//有一些运算符,如果我们不自己写 该运算符的重载,那么系统会自动给我们生成一个。比如赋值运算符的重载。
//Time myTime;
//Time myTime2;
//myTime2 = myTime;
//二、拷贝赋值运算符
Time myTime11; // 调用了Time::Time()构造函数
Time myTime22 = myTime; // 调用了Time::Time(Time &tmptime, int a) 拷贝构造函数
Time myTime5 = { myTime }; // 调用了Time::Time(Time &tmptime, int a) 拷贝构造函数
Time myTime6; // 调用了Time::Time()构造函数
myTime6 = myTime5; //这个是赋值运算符,既没调用构造函数,也没嗲用拷贝构造函数。
// 系统会调用一个拷贝赋值运算符。
// 我们可以自己重载赋值运算符,如果我们自己不重载,编译器也会为我们生成一个(编译器格外喜欢赋值运算符)。
// 编译器生成的赋值运算符重载比较粗糙。一般就是将非static成员赋值给赋值运算符左侧的对象的对应成员中去。
// 如果你这个成员是个类对象的话,可能还会调用这个类的拷贝赋值运算符。
// 为了精确控制Time类的赋值动作,我们往往会自己来重载赋值运算符。
//重载赋值运算符:有返回类型和参数列表,这里的参数就表示运算符的运算对象,比如myTime5就是运算对象。
//myTime6 就是this 对象。myTime5就是 operator=里边的参数。
//三、析构函数: 相对于构造函数,对象在销毁的时候,会自动调用析构函数。
//如果我们自己不写自己的析构函数,编译器也会生成一个默认的析构函数。默认析构函数的函数体为空{},表示默认的析构
//函数没干什么有意义的事。
//构造函数里new ,delete.
//析构函数也是类的成员函数,它的名字是由“~” 接类名构成,没有返回值,不接受任何参数,不能被重载,所以一个给定的
//类,只有唯一一个析构函数。
///a)函数重载:就是系统允许函数的名字相同,但是这些同名函数的参数个数或者参数类型不同,系统允许这些同名函数同时存在,
//当我们调用这些函数的时候,系统根据调用这个函数时我们所提供的参数类型,参数个数,就能区别出来你到底想调用哪个函数。
//b)构造函数的成员初始化:干了两个事,函数体之前和函数体之中。
//c). 析构函数的成员销毁: 干了两个事,函数体,函数体之后
//成员变量的初始化和销毁时机问题:先定义的先初始化,销毁时先定义的后销毁。
//d). new 对象和delete对象。 new对象的时候,系统调用了Time类的构造函数。
Time *pmytime5 = new Time; //调用不带参数的构造函数。
Time *pmytime6 = new Time(); //调用不带参数的构造函数。
//但是,大家务必要注意,我们new出来的对象,必须要自己释放,否则就会造成内存泄漏。
//在程序停止运行之前的某个时刻,你一定要用delete 把对象占用的内存释放掉。
delete pmytime5;
delete pmytime6;
// 你什么时候delete ,系统就会在什么时候去调用类Time 的析构函数。
system("pause");
return 0;
}