构造函数
系统在没有构造函数时,会生成一个"合成的默认构造函数",这个能干的事情很简单,合成默认构造函数无法正确的处理很多成员变量初始化问题;
例如一个类中包含一个其他类类型的成员变量,而这个其他类中存在唯一的构造函数并且是带单参数的,那么编译器就无法初始化该成员变量,所以必须定义自己的构造函数
示例:
合成默认构造函数不行的情况,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 = 3;
int b = a; //普通的复制
类中的复制:
实际上,在默认情况下,类对象的复制是每个成员变量的逐个复制
下图中演示没有拷贝构造函数的情况
拷贝构造函数的概念
拷贝构造函数也叫复制构造函数
如果一个类的构造函数的第一个参数是所属类类型的引用, 若有额外的参数,那么这些额外的参数都有默认值,改构造函数的默认参数必须放在函数声明中, 除非该构造没有函数声明, 那么这个构造函数就叫拷贝构造函数
这个拷贝构造函数会在一定的实际被调用
拷贝构造函数的声明:
定义:
注:每个类中只能定义一个拷贝构造函数
完整demo如下:
#include <iostream>
using 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); // 第一个参数是所属类类型引用,都有默认值
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;
}
int main()
{
Time T1;
Time T2 = T1;
Time T3(T1);
Time T4{ T1 };
Time T5 = { T1 };
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==其实是一个成员函数,所以就会有返回类型和参数列表.
有些运算符,如果不自己写该运算符的重载,那么系统会自动给我们生成一个. 比如赋值运算符的重载.
示例:
#include <iostream>
using 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成员的赋值给赋值运算符左侧的对象的对应成员中去.
赋值运算符重载
接着上面的代码,添加赋值运算符重载
#include <iostream>
using 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();
注意:没有返回值,不接受任何参数,不能被重载,一个类只能有一个析构,不存在重载函数,因为没参数;
示例
注:此示例包含构造/拷贝构造/赋值运算符重载/析构函数,接着上个例子补充
#include <iostream>
using 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.
}
1131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
