类与对象 在C++中,类和对象的出现,是为了完善C语言的不足,在struct的基础上慢慢进步,慢慢完善,将其的功能发挥到最大,也方便使用!
类与对象可谓是非常的重要了,所以在这里我们分为几篇来学习类与对象,在接下来的学习中,我们需要反复琢磨,去好好复习,才能学的好,学的牢,学的扎实!
有没有这种情况,在C语言阶段编写数据结构的时候,是不是多多少少会忘记初始化??
结果定义以后,忘记Init??在一顿操作以后,总会忘记destroy??
对,我们多多少少会忘记,所以在C++类和对象中呢,就出现了这样的函数:构造函数和析构函数
默认成员函数:用户没有显式实现,编译器会生成的成员函数称为默认成员函数。
构造函数,他不是真正去构造一个函数,只是向我们上面所说的,去初始化一个对象。
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Init(2022, 7, 5);
d1.Print();
Date d2;
d2.Init(2022, 7, 6);
d2.Print();
return 0;
}
对于Date类,可以通过 Init 公有方法给对象设置日期,但如果每次创建对象时都调用该方法设置 信息,未免有点麻烦,那能否在对象创建时,就将信息设置进去呢?
构造函数 是一个 特殊的成员函数, 名字与类名相同 , 没有返回值 , 创建类类型对象时由编译器 自动调用 ,以保证每个数据成员都有 一个合适的初始值,并且在对象整个生命周期内只调用一次 。
所以有了构造函数以后,就可以直接这样:
class Date
{
public:
//构造函数
Data(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
......
};
int main()
{
Date d1(2022, 7, 5);
d1.Print();
Date d2(2022, 7, 6);
d2.Print();
return 0;
}
构造函数可以重载(重载(点击链接有详细解释),函数名相同,参数不同就构成重载)
为什么要构成重载呢?
目的是为了实现多种初始化的方式:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
Date()
{
_year = 0;
_month = 0;
_day = 0;
}
Date(int year=1, int month=1, int day=1)
{
_year = year;
_month = month;
_day = day;
}
三种初始化的函数都构成函数重载,但是第二个和第三个却不能同时在一起使用,因为全缺省和无参数是一种情况,当调用时,会发生二义性,运行失败:
int main()
{
Date d1(2022, 7, 5);
Date d2(2022, 7, 6);
// 无参数时,要这样调用,不可以Data d3();,会与函数声明发生冲突
//,就相当于 Data func();,是错误的
Date d3;
return 0;
}
如果类中没有显式定义构造函数,则 C++ 编译器会自动生成一个无参的默认构造函数,一旦
用户显式定义编译器将不再生成。
那么编译器自动生成的无参默认构造函数可以直接使用吗?
没有类中显示的构造函数,使用默认的构造函数:
class Date
{
public:
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
d1.Print();
}
默认构造函数对内置类型不进行处理,只对自定义类型进行处理。
所以需要我们自己去写构造函数!
内置类型:语言自己提供的类型:int,double,char....
自定义类型:class/struct + stack/queue/person.... 类或者结构体等...
所以,我们自己不写,编辑器会自动生成,内置不处理,只处理自定义类型。
但是需要看需求才来决定是否需要自己写,不能光看内置类型还是自定义类型
面向需求:编译器默认生成就可以满足,就不用自己写,不满足就需要自己写
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack(int capacity = 4)" << endl;
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
void Push(int x)
{
// ....
// 扩容
_a[_top++] = x;
}
private:
int* _a;
int _top;
int _capacity;
};
class MyQueue {
public:
void push(int x)
{
_pushST.Push(x);
}
Stack _pushST;
Stack _popST;
//size_t _size;
};
对于MyQueue这个类中,有Stack _pushST; Stack _popST;两个自定义类型,发现在MyQueue类中没有显示的构造函数,就会使用自定义类型默认的构造函数,回Stack中使用构造函数。
那么说不对内置类型处理,那如果成员变量中,既有内置类型,又有自定义类型,那应该怎么办?
利用缺省值来处理内置类型:
class MyQueue {
public:
void push(int x)
{
_pushST.Push(x);
}
Stack _pushST;
Stack _popST;
size_t _size=0;
};
这样既有内置类型,又有自定义类型时,就可以调用构造函数初始化了。
无参的构造函数和全缺省的构造函数都称为默认构造函数,并且默认构造函数只能有一个。
注意:无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数,都可以认为
是默认构造函数。
举例说明:
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack(int capacity = 4)" << endl;
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
void Push(int x)
{
// ....
// 扩容
_a[_top++] = x;
}
private:
int* _a;
int _top;
int _capacity;
};
class MyQueue {
public:
void push(int x)
{
_pushST.Push(x);
}
Stack _pushST;
Stack _popST;
size_t _size=0; //这里不是初始化,是缺省值
};
int main()
{
MyQueue q;
return 0;
}
在定义一个MyQueue类的 对象q时,类中没有已经写好的构造函数,就要使用编译器默认的构造函数,那么内置类型有缺省值,自定义类型也要使用默认构造函数,默认构造函数只有三种情况:无参构造函数、全缺省构造函数、我们没写默认给出的,stack类中,刚好时全缺省作为了默认构造函数,有默认构造函数,可以使用。
但如果改变一个条件,将stack缺省值去掉:
还可以使用吗?
当然不可以!
首先,Queue类创建对象初始化时,我们发现Queue本身没有构造函数,那么他就会调用编译器提供的默认构造 ,内置类型不处理,但有缺省值,自定义类型调用默认构造,但发现Stack类中,没有默认构造函数(无参构造函数、全缺省构造函数、我们没写默认给出的),因为自己写了,stack类就不会自己提供。所以无法初始化。
若使用编译器自己提供的,能满足我们需求吗?
可以看出,默认提供的并没有将数组开辟空间,不能满足我们的需求。
结论:面向需求:编译器默认生成就可以满足,就不用自己写,不满足就需要自己写
那我们可不可以直接把 int* _a = (int*)malloc(sizeof(int)*4); malloc作为缺省值呢?
居然发现是可以的,但是有坏处是,无法调试他是否开辟成功。
那么定义类时,构造函数会自动初始化,
那结束时,有没有自动destroy,自动清理内存空间的函数呢?
当然有:
析构函数 :与构造函数功能相反,析构函数不是完成对对象本身的销毁,局部对象销毁工作是由
编译器完成的,而是 对象在销毁时会自动调用析构函数,完成对象中资源的清理工作 。
1. 析构函数名是在类名前加上字符 ~ 。(~这个符号在C语言里面是二进制取反)
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义,系统会自动生成默认的析构函数。 注意:析构
函数不能重载,因为没有参数,所以不存在析构函数。
4. 对象 生命周期 结束时, C++ 编译系统系统自动调用析构函数。
析构函数在对象生命周期结束时自动调用,生命周期得具体看,如果在局部域(函数内部),则函数调用完毕后,就会结束局部变量的生命周期,全局域,malloc(手动结束)。
class Stack
{
public:
//析构函数名是在类名前加上字符 ~
~Stack()
{
free(_a);
_a=nullptr;
_top=_capacity=0;
}
private:
int* _a;
int _top;
int _capacity;
};
析构函数也是一样的,类比构造函数。如果自己没写,那么编译器就会自动生成,且内置类型不处理,自定义类型处理。就比如 int*_a,编译器他不清楚是一个单纯的指针,还是它指向动态内存空间,不知道应该怎么处理。
至于要不要自己写,就要看默认的,即编译器自动生成的满不满足我们的需求。
首先要知道,拷贝构造函数也是构造函数的重载。
那在创建对象时,可否创建一个与已存在对象一模一样的新对象呢?
拷贝构造函数:只有单个形参,该形参是对本类类型对象的引用(一般常用const修饰),在用已存 在的类类型对象创建新对象时由编译器自动调用。
举例:日期类:
class Date
{
public:
//构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
_year = year;
_month = month;
_day = day;
}
void print()
{
cout << _year << " " << _month << " " << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 10);
Date d2(d1); //拷贝d1
d1.print();
d2.print();
return 0;
}
拷贝构造函数也是特殊的成员函数,其特征如下:
1. 拷贝构造函数是构造函数的一个重载形式。函数名相同,参数不同。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用,使用传值方式编译器直接报错,因为会引发无穷递归调用。 发生递归的原因: Date(Date d) //去掉引用,就是传值调用 { _year = d._year; _month = d._month; _day = d._day; } 传值调用:当调用拷贝构造函数时,形参是实参的一份临时拷贝 调用拷贝构造Date d2(d1);,先得传参,传参调用完拷贝构造以后,本身又要调用拷贝构造,而后又要传参,然后一直自己调用自己,导致一直递归下去......
那么传地址可不可以?可以,但不就麻烦了吗? Date(Date *d) //去掉引用,就是传值调用 { _year = d->_year; _month = d->_month; _day = d->_day; } 所以还是引用是最好的方式!
3.拷贝构造函数只有单个形参,该形参是对本类类型对象的引用,一般常用const修饰 为什么要加const呢? Date(const Date & d) //去掉引用,就是传值调用 { _year = d._year; d._month=_month ; //有时候会写反,而改变了原本对象的值。 _day = d._day; } Date d2(d1); //拷贝d1 所以加了const以后,就不能改变d1原对象了
4. 若未显示定义,编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按
字节序完成拷贝,这种拷贝叫做浅拷贝,或者值拷贝。
在编译器生成的默认拷贝构造函数中,内置类型是按照字节方式直接拷贝的,而自定
义类型是调用其拷贝构造函数完成拷贝的。所以内置类型处理,自定义类型不处理,自定义类型可能复杂多变,需要自己写拷贝函数,这样就叫 深拷贝。
浅拷贝: 自己没有写,使用默认的 (日期类)
class Date
{
public:
//构造函数
Date(int year = 1900, int month = 1, int day = 1)
{
cout << "构造函数" << endl; //验证调用所需
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022, 10, 10);
Date d2(d1); //拷贝d1
return 0;
}
是可以实现我们想要的功能的,所以不需要我们自己写。
举例:(栈类)
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack(int capacity = 4)" << endl;
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
//析构函数
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void Push(int x)
{
// ....
// 扩容
_a[_top++] = x;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack s1;
s1.Push(1);
s1.Push(2);
Stack s2(s1);
}
当使用默认拷贝函数时,是否能实现我们想要的需求:
这是怎么了??编译器自己提供的默认拷贝构造函数居然把s1拷贝到s2类中时,两个类中的指针变量指向了同一块空间!!
那么,栈的特性就是先进后出,所以s2先调用析构函数,把空间清理了,然后s1再去调用析构函数,又去清理,这不是瞎搞嘛,造成内存重复释放!
所以默认的拷贝构造函数解决不了我们的需求,需要我们自己写。
//st2(st1)拷贝构造
Stack(const Stack& st)
{
cout << "Stack(const Stack& st)" << endl;
_a = (int*)malloc(sizeof(int)*st._capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memcpy(_a, st._a, sizeof(int)*st._top);
_top = st._top;
_capacity = st._capacity;
}
即解决了指针重复指向一块空间,又把已经创建好的s1对象和其中的内容都拷贝到了s2。
总结:需要写析构函数的类,都需要写深拷贝的拷贝构造,如:Stack
不需要写析构函数的类,默认生成的浅拷贝的拷贝构造就可以用 。如:Date/MyQueue
类中如果没有涉及资源申请时,拷贝构造函数是否写都可以;一旦涉及到资源申请
时,则拷贝构造函数是一定要写的,否则就是浅拷贝。
为了让自定义类型可以使用 运算符
对于日期类,我们会经常用到,某个日期加多少天来得到另一个日期。
所以日期需要加减,也需要比较,那么使用+ = - ,在C++中,就需要运算符重载,与函数重载没有关系。
返回值+operator+运算符 +(所需参数),参数个数就是参与运算符的参数个数
class Data
{
public:
Data(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
};
bool operator==(Data& d1,Data& d2)
{
return d1._year == d2._year
&& d1._month == d2._month
&& d1._day == d2._day;
}
int main()
{
Data d1(2022, 10, 11);
Data d2(2023, 1, 1);
d1==d2;//可以显式调用 operator==(d1,d2);
cout << (d1 == d2) << endl;
cout << (d1 > d2) << endl;
}
1.定义运算符重载时,参数为引用的好处是,不需要调用拷贝函数,若是传值,参数为对象,则需要拷贝对象,调用拷贝函数。
2.定义在类外,需要将类的成员变量设置为公开,会造正麻烦,那么我们直接就定义到了类的内部。
3.若直接放入类的内部定义运算符重载,则会出现问题:
class Data
{
public:
Data(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
}
bool operator==(Data& d)
{
return this->_year == d2._year
&& this->_month == d2._month
&& this->_day == d2._day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1(2022, 10, 11);
Data d2(2023, 1, 1);
d1==d2;//可以显式调用 operator==(d1,d2);
cout << (d1 == d2) << endl;
cout << (d1 > d2) << endl;
}
那为什么在类中,显示的是一个参数呢? bool operator==(Data& d) { return this->_year == d2._year && this->_month == d2._month && this->_day == d2._day; }
因为在类中定义的成员函数,都在公共区,自动会在参数中带一个this指针,为该类的创建的对象的地址。而且运算符重载限定了参数个数,则参数部分:bool operator==(Data& d)即为这样,实现则为 return this->_year == d2._year && this->_month == d2._month && this->_day == d2._day;
值得注意的一点是:加 +和 加等于+=是不一样的:
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class Data
{
public:
Data(int year=1,int month=1,int day=1)
{
_year = year;
_month = month;
_day = day;
}
int Getmonthday(int year, int month)
{
int a[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 4 == 0))
{
return 29;
}
else
return a[month];
}
Data& operator+=(int day)
{
_day += day;
while (_day> Getmonthday(this->_year, this->_month))
{
_day -= Getmonthday(this->_year, this->_month);
_month++;
if (_month > 12)
{
_month -= 12;
_year++;
}
}
cout << _year<<_month<<_day << endl;
return *this;
}
Data operator+(int day)
{
Data ret(*this);
ret +=day;
return ret;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Data d1(2022, 10, 11);
Data d2(2023, 1, 1);
d1 + 100;
d1 += 100;
return 0;
}
还有其他运算符重载需要大家自己实现!
参数类型 : const T& ,传递引用可以提高传参效率(赋值
返回值类型 : T& ,返回引用可以提高返回的效率,有返回值目的是为了支持连续赋值
返回 *this :要复合连续赋值的含义
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
d1=d2;
赋值也是一样的,有两个参数,只不过第一个是隐藏的,赋值重载也是有顺序的:d1=d2;那么传参时,d1就是第一个参数,d2就是第二个参数。(像有双操作数的运算符,前后顺序就是参数顺序)
参数加const是因为原赋值对象不希望被改变,引用作为参数也可以避免拷贝;返回类型为引用是因为可以避免调用一次拷贝构造;遇到连等的情况:d1=d2=d3;链式访问(从右到左依次执行),d2=d3;会返回d2,再执行d1=d2;这就是有返回值的好处。
引用在传值传参和传值返回时,都可以减少拷贝构造的调用,节省时间空见。
返回值返回d1和d2都是可以的,只不过在返回d2时,前面返回类型就要加const,否则会扩大权限,所以为了更加方便,返回d1,即*this。
d1=d2;就是把d2的值赋值给d1,那么是不是和拷贝构造也有相似之处呢??
当然,但二者的区别是:拷贝构造:用已存在的类类型对象 创建新对象,赋值重载:已存在的两个对象之间的拷贝
他们都是会对内置类型进行处理,自定义类型会调用它的默认构造函数。
他们都是默认成员函数,自己不写,编译器就会默认生成。关键在于,编译器默认提供的,能不能符合我们的需求!
那么我们之前总结过,拷贝构造,当要调用析构函数时,就需要我们自己去写,赋值重载也是一样的。
举例说明:栈
如果使用编译器默认的赋值重载:
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack(int capacity = )" <<capacity<<endl;
_a = (int*)malloc(sizeof(int)*capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
_top = 0;
_capacity = capacity;
}
// st2(st1)
Stack(const Stack& st)
{
cout << "Stack(const Stack& st)" << endl;
_a = (int*)malloc(sizeof(int)*st._capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memcpy(_a, st._a, sizeof(int)*st._top);
_top = st._top;
_capacity = st._capacity;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
void Push(int x)
{
// ....
// 扩容
_a[_top++] = x;
}
private:
int* _a;
int _top;
int _capacity;
};
int main()
{
Stack st1;
st1.Push(1);
Stack st2(10);
st2.Push(1);
st2.Push(2);
st2.Push(3);
st1 = st2;
return 0;
}
会发现和之前的拷贝构造出现的问题挺一样的,d1和d2的_a指向的空间是一样的,结果同一块空间还析构了两次,d1原本指向的空间,没人析构,造成内存泄露。当要调用析构函数时,就需要我们自己去写。
解决方案:既然是赋值,就得内存空间一样大,里面内容一样。
索性直接将d1内存空间直接释放,创建一个和d2一样大的内存空间,然后将里面内容拷贝进去。
也防止自己赋值自己,直接把自己的内存空间释放了。
代码如下:
Stack& operator=(const Stack& st)
{
if (this != &st)
{
free(_a);
_a = (int*)malloc(sizeof(int) * st._capacity);
if (_a == nullptr)
{
perror("malloc fail");
exit(-1);
}
memcpy(_a, st._a, sizeof(int) * st._top);
_top = st._top;
_capacity = st._capacity;
}
return *this;
}
<<在C语言中是左移的意思,但在c++中却是流插入的意思。
int i=5; cout<<i; <<流插入运算符,这个运算符支持内置类型(int,double,char......),是因为他在库中就已经实现了,而cout能用<<,是因为cout的类中也已经实现了使用流插入的功能。 cin和cout在库中对应的类是:istream,ostream,都已经支持自定义类型。 自定义类型要用运算符,就必须要重载,内置类型天生就可以用运算符。
void operator<<(ostream& out)
{
out << _year << " " << _month << " " << _day << endl;
}
若写在类中,那么参数就只能这么写,因为第一个参数为隐藏this指针,第二个是ostream类。
对于双操作数的运算符,写的顺序就是参数的顺序,那么调用时,我们只能这么写:
d1<<cout;但是这样总是很怪,流插入不应该流向cout吗?那么我们放在类外依旧在.h中,写成全局函数试试:
void operator<<(const ostream& out, const Date& d)
{
out << _year << " " << _month << " " << _day << endl;
}
问题一:
这样的话,在.cpp和其他包含.h头文件的文件里,在编译预处理时,.cpp->.o /.obj 就会在各个文件中,都有<<流插入运算符重载的定义,那么在其他文件中就会产生符号表,符号表中有重名的就会报错。
解决办法:
1.static修饰函数,会改变链接属性(是在当前文件可见),在其他文件不会产生符号表。那么不产生符号表,直接就会使用定义,不会发生冲突。
2.声明和定义分离 .h中声明,.cpp中定义,就不会发生符号表重复。
3.加inline内联,加了内联,就不会产生符号表,也是直接展开,定义到了每个有.h的文件,直接使用定义,不会链接。void operator<<(const ostream& out, const Date& d);
问题二:
既然出了类,类中的私有成员变量就不能通过对象去使用。
解决办法:
1.偷家,私有成员变量不可以用,但我可以通过公有的成员函数去使用。
2.友元:友元声明(在类和对象下我们会详细说明),在类中的声明前加一个friend.
friend void operator<<(const ostream& out, const Date& d);
那么有时候我们也会遇到这样的情况:cout<<d1<<d2;
链式访问,这就和之前的赋值重载很一样了,需要返回值,不同的是,<<的链式访问是从左到右的。而且返回值当然得是cout了
ostream& operator<<(const ostream& out, const Date& d); 你懂了吗??
流插入是一样的!
将const修饰的“成员函数”称之为const成员函数。
而在调用的时候会经常出现 权限放大的问题。权限可以缩小,平移,但不可以放大
1.举例说明:
为什么就会报错呢??
当d2去调用的时候&d2(即const Date*),这里const修饰的是指针所指的对象不可以被修改,只读。但是传参的时候就成了Print(Date*const this),可读可写(不明白可以回顾以前文章)。所以扩大了权限,无法调用。
解决方法就是在函数定义后面加一个const
就相当于 const Date*const,权限此时就相同了。
而加了const以后,d1调用时&d1,Date*,可读可写,但是Print形参中是只读,虽然权限缩小,但是可以!
2.举例说明:
日期类相减: int Date:: operator-(const Date& d) { Date max = *this; Date min = d; int flag = 1; //if (*this < d) 换为 if(d>*this) 可以吗?? 当然不可以,d.operator>(*this); { &d ->(const Date*)d此时是只读,结果到了>运算符的参数就是 Date*const可读可写,权限放大。 max = d; min = *this; flag = -1; } int count = 0; while (max != min) { max--; count++; } return count * flag;; }
所以最好的方式是:凡是内部不改变成员变量,其实也就是不改变*this对象的数据的,这些成员函数都应该加const。
六大类默认成员函数就是:自己不写,编译器会给出。
当然,取地址重载也不例外,所以在大多数的时候,我们使用取地址都不需要自己写,除非一种情况!!
就是我不想让他取出地址:
Date* operator&()
{
return nullptr;
//return this;
}
//第二种返回值加const是因为,返回参数是this时,为了返回时不扩大权限
const Date* operator&() const
{
return nullptr;
//return this;
}
看到这里,类和对象中篇就结束了,是不是收获满满,当然也需要反复琢磨,让我们一起期待类和对象下。跨过难关,旗开得胜!!