C++类与对象（中）

最新推荐文章于 2024-08-12 16:55:46 发布

wht6587

最新推荐文章于 2024-08-12 16:55:46 发布

阅读量1.2k

点赞数 52

分类专栏： C++ 文章标签： c++ 开发语言 c语言

本文链接：https://blog.csdn.net/m0_74085682/article/details/138256146

版权

C++ 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

前言：

上一章介绍到类中的成员函数第一个参数默认是this指针，这章将对类中的成员函数作详细介绍

1.C++中的默认成员函数

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

2.构造函数

2.1概念

构造函数是一个特殊的成员函数，名字与类名相同，定义类的对象时由编译器自动调用，以保证对象中每个数据成员都有一个合适的初始值或者是为其开适当的空间，并且在对象整个生命周期内只调用一次。


class Date
{
public:
    //构造函数
    Date()
    {

    }
 
private:
    int _year;
    int _month;
    int _day;
};

2.2性质

1.函数名与类名相同

2.无返回值

3.类实例化为对象时（也就是定义对象时）编译器会自动调用对应的构造函数

4.如果类中没有显式声明定义构造函数，则编译器会自动生成一个无参的默认构造函数

5.构造函数可重载


class Date
{
public:
    // 1.无参构造函数
    Date()
    {}
 
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

6.无参的构造函数和全缺省的构造函数以及编译器自动生成的构造函数（当类中没显式声明定义时）都称为默认构造函数

【总的来说，不需要传入参数的构造函数就可以称为默认构造函数】

此时想必你会好奇编译器自动生成的默认构造函数能做什么

C++中有两种类型，分别为内置类型（int/char/...）和自定义类型（class/struct/...定义的类型），编译器自动生成的默认构造函数对对象中的内置类型成员不做处理，对自定义类型成员会去调用它们各自的默认构造函数进行初始化。

2.3使用

此处MyQueue自定义类型成员会去调用它们各自的默认构造函数进行初始化

class Stack
{
   //.......
};
 
class MyQueue
{
    Stack _st1;
    Stack _st2;
};

基本使用

class Date
{
public:

    // 1.全缺省构造函数
    Date(int year=1, int month=1, int day=1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
 
void TestDate()
{
    Date d1; // 调用全缺省构造函数
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    //Date d4();
    
    Date d5(2015, 1, 1); // 调用带参的构造函数
 
}

此外C++11对于编译器自动生成的默认构造函数对内置类型不做处理做了优化，打了一个补丁，即可以在内置类型声明时给缺省值（这里的缺省值其实是作为初始化列表的参数，下一章详细介绍），这里我们只需知道，默认构造函数会用此处的缺省值对内置类型进行初始化即可

class Time
{
public:
    Time()
    {
        _hour = 0;
        _minute = 0;
        _second = 0;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
    
private:
    //内置类型
    int _year = 1970;//缺省值：1970
    int _month = 1;  //缺省值：1
    int _day = 1;    //缺省值：1
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

总结：

一般情况都需要显式写构造，除了上述的MyQueue类，成员都是自定义类型且拥有自己的默认构造函数

3.析构函数

3.1概念

与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作，如：成员空间的释放

3.2性质

1.函数名与类名相同只不过需要在函数名前加上字符~

2.无参数无返回值

3.一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载（可以用第2点解释）

4.对象生命周期结束后自动调用

5.析构函数类似构造函数，对内置类型不做处理，对自定义类型调用它的析构函数

3.3使用

如下日期类我们有必要显式写析构函数吗？

class Time
{
public:
    Time()
    {
        _hour = 0;
        _minute = 0;
        _second = 0;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
    
private:
    //内置类型
    int _year = 1970;
    int _month = 1;  
    int _day = 1;    
    // 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

不需要!对于内置类型我们无需清理其空间等对象生命周期结束编译器会清理，而编译器自动生成的默认构造函数对于自定义类型会调用其析构函数，所以我们也无需处理。所以什么时候我们需要显式写呢？

答案是：当你有自己为类中的成员开辟空间，并且此空间需要手动释放时，如malloc等

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 3)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    // 其他方法...
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
void TestStack()
{
    Stack s;
    s.Push(1);
}

总结：

1.需要写析构，有空间需要手动释放，如Stack...

2.不需要写析构 a.没有空间需要手动释放，如Date

b.类中成员都为自定义类型且有自己的析构函数，如MyQueue类

4.拷贝构造函数

4.1概念

使用一个已经存在的对象去初始化另一个正在被创建的对象

4.2性质

1.拷贝构造函数是构造函数的一个重载形式

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // 正确写法
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    Date d2(d1);
    return 0;
}

浅谈引发无穷递归的原因：自定义类型传值传参要调用拷贝构造函数

函数传自定义类型参数时

3. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

【可以知道默认生成的拷贝构造函数对Date类足够用了，但是对Stack这种需要开空间的类若是让stack1去给stack2拷贝初始化，因为是值拷贝，会导致stack1和stack2共用一块空间，这显然不是我们想要的，对于这种情况我们就需要写深拷贝的拷贝构造解决】

4.3使用

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
    Date d1;
    //两种用法
    Date d2(d1);
    Date d3=d1;
    return 0;
}

总结：

1.需要显式写，类内部成员有手动开空间，需要深拷贝，如Stack

2.不需要显式写，类内部成员没有手动开空间，只需浅拷贝，如Date

5.赋值拷贝函数（赋值重载函数）

开始介绍前需要先知道运算符重载的概念

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号

函数原型：返回值类型 operator操作符(参数列表)

返回值的类型一般取决于操作符想要实现的功能

注意事项：

1.不能通过连接其他符号来创建新的操作符：比如operator@

2.重载操作符必须有一个类类型参数（不要忘记this指针）

3.用于内置类型的运算符，其含义不能改变，例如：内置的整型++，不能改变其含义（其实能改，但没必要）

4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

5. 【. *】【::】【sizeof】【?:】【 .】注意以上5个运算符不能重载。这个经常在笔试选择题中出现

// 全局的operator==
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //private:
    int _year;
    int _month;
    int _day;
};
//需要Date::才能访问到类中的成员
bool Date::operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
        && d1._month == d2._month
        && d1._day == d2._day;
}
void Test()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout << (d1 == d2) << endl;
}

5.1赋值拷贝函数概念

将一个已经存在的对象赋值给另一个已经存在的对象

5.2 性质和使用

1.参数类型：const T&，传递引用可以提高传参效率

2.返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

3.检测是否自己给自己赋值

3.返回*this ：要复合连续赋值的含义

4.若没显式写，编译器会生成默认的，以值的方式逐字节拷贝。内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
 
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
 
    Date& operator=(const Date& d)
    {
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
 
        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
	Date d1;
	Date d2;
	d1 = d2;
	return 0;
}

注意：

与拷贝构造同理，如果成员有需要开空间的，需要显式写

6.&以及const &操作符重载函数

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};