浅谈类的六个默认的成员函数

Love The Way You Lie 2022-09-23 03:43 131阅读 0赞

##  *面向对象程序设计:在C++中类和对象的定义和使用范例：* ##

下面我们先来看一个关于日期类的功能实现代码：

#include<iostream>
    using namespace std;
    
    class Data
    {
    public:
    	//Data();        //不带参的构造函数
    	Data(int y=2017,int m=1,int d=1);   //带参的构造函数
    	void print();
    private:
    	int year;
    	int month;
    	int day;
    }; 
    
    Data::Data(int y,int m,int d)  //全缺省
    {
    	year=y;
    	month=m;
    	day=d;
    }
    
    void Data::print()
    {
    	cout<<year<<"-"<<month<<"-"<<day<<endl;
    }
    
    int main()
    {
    	Data d1;
    	Data d2(2016,7,3);
    	d1.print();
    	d2.print();
    	return 0;
    }

# *类的构成：数据成员，成员函数* #

1.类的定义与结构体类似，不同之处在于：如果结构体和类都没有限定符，结构体中默认是公有的(public),类中默认是私有的(private)

2.可以在类内定义成员函数也可以在类外定义成员函数，比如上述代码就是在类外定义成员函数的

#  *类的访问限定符：public,private,protected* #

1.public可以从类外部直接访问，private/protected不能从类外部直接访问

2.每个限定符在一个类中可以使用多次，它的作用域从该限定符出现到下一个限定符之前或类体结束前

3.类的访问权限体现了类的封装性

4.protected:称为类的保护部分，用它来修饰的话：成员可以由该类和该类的派生类的成员函数来访问，类外是无法访问的(此限定符到学到继承时再详细理解)

#  *类的作用域* #

在C++的作用域分类中，除了C和C++共有的局部域和全局域之外还有C++特有的类域和名字空间域:

类域(类的作用域)

1.在类外定义成员需要使用::(作用域解析符)来指明属于哪一个类

2.访问方式与结构体类似,对象可以通过.直接访问数据成员，指向对象的指针可以通过\->来访问类中的成员

3.类的成员都在类的作用域内，成员函数可任意访问成员变量和其他成员函数

# *隐含的this指针* #

1.this指针是成员函数的隐含指针形参，我们不能在成员函数的形参中添加this指针的参数定义，也不能在调用时显示this指针

2.在对象调用成员函数时，对象地址作为实参传递给成员函数的第一个指针形参this指针

3.每个成员函数都有一个指针形参，是隐含的(构造函数和静态成员函数比较特殊没有这个隐含的this指针；因为构造函数的作用是对数据成员进行初始化，在调用构造函数之前还没有初始化当然没有这个隐含的this指针了，但是值得注意的一点是虽然构造函数没有这个隐含的this指针但是却可以在构造函数体内使用这个this指针)

在上述代码中调用print函数时就传过来的是隐含的this指针，具体分析见下图:

![Center][]

# *类的六个默认的成员函数：构造函数，拷贝构造函数，析构函数，赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载*  #

# *构造函数* #

在上述Data类中有两个函数Data(int y,int m,int d);和Data(),这两个函数就是构造函数(用于给类的数据成员初始化)

构造函数的特点：(构造函数就是特殊的成员函数)

1.函数名与类名相同

2.构造函数是没有返回值也没有类型的，在定义构造函数时，是不能说明构造函数的类型的，甚至定义为void也不行，没有类型不等于类型为空.

3.如果类中没有定义构造函数，则C++编译器会自动产生一个缺省的构造函数，如果定义了就使用这个定义的构造函数

4.构造函数可以重载,比如在上述代码中定义了两个构造函数Data

5.构造函数也和普通的成员函数类似，即可以在类内定义也可以在类外定义

6.对象实例化时自动调用对应的构造函数

7.无参的构造函数和全缺省的构造函数都是缺省的构造函数，并且缺省的构造函数只能有一个；因为如果创建一个类的对象是不带参的，本来此时应该调用的是默认的构造函数，但是当用户自己实现了构造函数时系统那个默认的构造函数是不会起作用的，而用户自己实现的构造函数又是必须传参的，此时就会发生错误；如果用户实现的构造函数是全缺省的那就不同了，我们知道无参的构造函数和全缺省的构造函数都是属于缺省构造函数的，当用户实现的构造函数是全缺省的即使不传参数系统也不会报错，因为有缺省值啊！！但是无参的构造函数和全缺省的构造函数是不能同时出现的，当用户创建一个不带参的对象时会出现调用不明确的情况，因为不带参的对象调用构造函数时它可以调用无参的也可以调用全缺省的，如果同时出现确实让编译器头疼啊！！

8.构造函数不存在隐含的this指针.因为构造函数的作用是给数据成员初始化，此时还未初始化所以不存在隐含的this指针

# ***构造函数的两种初始化方式：*** #

1).构造函数体内进行赋值

2).初始化列表的方式 (高效)

初始化列表是以一个冒号开始，接着一个逗号分隔数据列表，且每个数据成员都放在一个括号中进行初始化

# ***必须放在初始化列表中的成员变量：*** #

1).常量成员变量(const 修饰变量时在C++中该变量具有常性：一经初始化就不可再修改了，所以const修饰的成员变量中必须放在初始化列表中初始化)

2).引用类型成员变量

3).没有缺省构造函数的类成员变量(在日期类和时间类中，要输出日期和时间就得在日期类中拷贝构造时间类的对象，如果这个时间类是没有默认的构造函数则必须放在日期类的初始化列表中初始化)

# *拷贝构造函数* #

##  定义：创建对象时使用同类对象来初始化  ##

1.拷贝构造函数其实是构造函数的重载

2.默认的拷贝构造函数是浅拷贝

3.拷贝构造函数的参数必须是引用传参，使用传值方式会引发无穷递归的现象

![Center 1][]

看上述拷贝构造函数的实现，读者是不是觉得拷贝构造函数的实现可有可无呢？其实并不是

在定义的数据成员中如果存在指针类型且必须在构造函数中为这个指针分配空间的情况下，用户必须自定义拷贝构造函数和析构函数 ，请看下面一个简单的例子：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    class Student  
    {  
    public:  
        Student(char *name,int age)  
        {  
            _name = (char *)malloc(sizeof(char)*(strlen(name)+1));  //多一个位置存\0
            if (NULL == _name)  
            {  
                cout << "out of memory" << endl;  
                exit(EXIT_FAILURE);  
            }  
            strcpy(_name,name);  
            _age = age;  
        }  
        ~Student()  
        {  
            free(_name);  
            _name = 0;  
        }  
    private:  
        char *_name;  
        int _age;  
    };  
    int main()  
    {  
        Student s1("zhangsan",20);  
        Student p2= s1;  
        system("pause");  
        return 0;  
    }

上述代码是存在问题的，详情请见下图分析：

![Center 2][]

自定义实现拷贝构造函数解决浅拷贝的问题：

Student(const Student &s)
    	{  
    		_name = new char[strlen(s._name)+1];  
    		if (_name != 0)  
    		{  
    			strcpy(_name,s._name);  
                _age = s._age;  
    		}   
    	}

#  *析构函数* #

析构函数：是一种特殊的成员函数，通常用于回收或者清理资源，它的特点如下：

1.析构函数在类名上加上字符~

2.析构函数无参数也无返回值

3.唯一性：一个类有且只有一个析构函数(不可重载)

4.析构函数不是删除对象而是清理

5.当程序执行到return 0;快要结束时系统自动调用析构函数

必须用户自定义的析构函数：在构造函数中分配空间的情况必须用户自定义析构函数

# *运算符重载(赋值操作符重载，取地址操作符重载，const修饰的取地址操作符重载...)* #

为了支持程序的可读性，C++支持运算符重载，那仫什仫是运算符重载的特点呢？下面让我们先来看一道简单的运算符重载的例子(它的作用是将简单的加法运算输出结果两个数为相减的结果):

#include<iostream>
    using namespace std;
    
    class Int
    {
    public:
    	Int(int d=0)   //全缺省的构造函数
    	{
    		_data = d;
    	}
    	Int operator+(Int m)
    	{
    		return Int(_data - m._data);
    	}
    
    public:
    	int _data; 
    };
    int main()
    {
    	Int a(3);
    	Int b(5);
    	Int c = a+b;
    	cout<<c._data<<endl;
    	return 0;
    }

由上述代码总结出以下运算符重载的特征：

1.赋值运算符的重载是对一个已经存在的对象进行赋值

2.运算符重载不改变运算符的优先级/结合性/操作符个数

3.几个C++不能重载的运算符：  .\* (点乘) / ::(作用域解析符) /  sizeof / ?:(条件运算符) / .

什仫是点乘？它是如何使用的？请看下面一个简单的使用范例：

#define _CRT_SECURE_NO_WARNINGS 1
    #include<iostream>
    using namespace std;
    
    class A
    {
    public:
    	void print()
    	{
    		cout<<"hehe"<<endl;
    	}
    };
    void (A::*pfun)()=&A::print;   //函数指针
    int main()
    {
    	A a;
    	a.print();  //hehe
    	(a.*pfun)();//hehe
    	system("pause");
    	return 0;
    }

*赋值操作符重载*：(以复数类为例)

Complex& Complex::operator=(const Complex &c)
    {
    	if(this != &c)
    	{
    		_real=c._real;
    		_image=c._image;
    	}
    	return *this;
    }

*取地址操作符重载*：

const Date *operator&()const
    	{
    		return this;
    	}

[Center]: /images/20220721/36a713d6bff34ea780a868d673e5cdbd.png
[Center 1]: /images/20220721/03a97ff97c394a068faa71b905f1d6f8.png
[Center 2]: /images/20220721/9996cad5882741c28e89b8b584e5a501.png