＜C++初阶＞类与对象(中)

已于 2022-07-10 17:46:59 修改
阅读量334 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-07-08 17:01:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shinamashiro_/article/details/124958904
版权

目录

1.类的6个默认成员函数

2.构造函数

2.1概念

2.2特性

3.析构函数

3.1概念

3.2特性

4.拷贝构造函数

4.1概念

4.2特性

5.赋值运算符重载

5.1运算符重载

6.日期的实现

6.1Date.h

6.2Date.cpp

7.const成员

7.1const修饰类的成员函数        

​编辑

8.取地址及const取地址操作符重载

1.类的6个默认成员函数

任何一个类在不写的情况下会自动生成6个成员函数。

class Date{}

2.构造函数

2.1概念

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象生命周期内只调用一次。

2.2特性

构造函数是特殊的成员函数，需要注意的是，构造函数的名字虽然叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

特征：

  1. 函数名与类名相同。
  2. 无返回值
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
class Date
{
public:
    //构造函数，无返回值，名字与类名相同，实例化时自动调用
    //无参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    //支持函数重载
    //带参构造函数
    Data(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //一般使用全缺省构造函数
    Data(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
}

int main()
{
    //Data d1(); 
    //无参数时不能有括号，会被编译器忽略。
    //无法区分是函数声明还是对象的定义应该如下：
    Data d1;
    Data d2(2022, 1, 1);
}

5.如果类中没有显式定义构造函数，C++编译器会自动生成一个无参的默认构造函数，一旦用户定     义编译器不再生成。 

6.默认构造函数(不传参就可以调用的构造函数)                                                                                  无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。           无参构造函数、全缺省构造函数以及编译器默认生成的构造函数，都认为时默认构造函数。

class Date
{
public:
    //使用时不能同时存在，默认构造函数只能存在一个
    //无参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    //全缺省构造函数
    Data(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
}

7.编译器生成默认的构造函数会对自定义类型成员调用它的默认成员函数                                           默认生成构造函数对于内置类型成员变量不处理，对于自定义类型成员变量才会处理。      

#include <iostream>
using namespace std;

class Stack
{
public:
	Stack()
	{
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
    //自定义类型
    //不能自己进行初始化，只能依赖默认构造函数，因为_st1为private，访问不了。
    MyQueue()
    {
        _st1._a = null.ptr
    }

	//只有自定义类型成员
	//默认生成的构造函数对_st1和_st2进行初始化
private:

    //C++11补丁:针对编译器自己生成的默认构造函数不初始化问题
    //给缺省值，编译器自己生成的默认构造函数使用
    int _size = 0;

	Stack _st1;
	Stack _st2;
};

int main()
{
    //类中的_st1和_st2被MyQueue类的默认构造函数会调用Stack的构造函数对其进行初始化
	MyQueue q;

	return 0;
}

   如果一个类中的成员全是自定义类型，可以用默认生成的构造函数。如果有内置类型的成员，或     者需要显示传参初始化，那么都要自己实现构造函数。

  若无默认构造函数给自定义类型调用，自定义类型便无法初始化，如下： 

#include <iostream>
using namespace std;

class Stack
{
public:
    //显示定义了构造函数，编译器便不会再自动生成默认构造函数
    //传参的构造函数不是默认构造函数
	Stack(int capacity)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		_top = 0;
        _capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
    //Stack类无默认构造函数给MyQueue的默认构造函数调用
private:
	Stack _st1;
	Stack _st2;
};

int main()
{
    //MyQueue无默认构造函数可以调用，无法进行初始化，程序报错
	MyQueue q;

	return 0;
}

3.析构函数

3.1概念

析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而对象再销毁时会自动调用析构函数，完成对象的一些资源清理工作。

3.2特性

析构函数是特殊的成员函数

特征：

  1. 析构函数名是在类名前加上字符~。
  2. 无参数返回值
  3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。    
    class Date
{
public:
    //无资源清理，不需要析构函数
    ~Date()
    {
        
    }
private:
    int _year;
    int _month;
    int _day;
}
      
    class Stack
{
public:
	Stack()
	{
		_a = nullptr;
		_top = _capacity = 0;
	}
    //析构函数
    ~Stack()
    {
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
    //栈里面定义对象
    //根据栈帧后进先出的性质，由于st2后定义，程序结束时st2比st1先调用析构函数
    Stack st1(1);
    Stack st2(2);

    return 0;
}
  4. 对象生命周期结束时，C++编译器系统自动调用析构函数。                                                      自动调用(对于内置类型不做处理，对于自定义类型会去调用它的析构函数，同构造函数)

4.拷贝构造函数

4.1概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2特性

拷贝构造函数时特殊的成员函数。

特征：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归。              (将自定义类型实参传值给函数形参要调用拷贝构造)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
    class Date
{
public:
    //拷贝构造函数
    //是构造函数的函数重载
    //& 必须使用引用传参，若是单纯的传值传参会引发无穷递归
    //const 使用&引用可能会改变d1，需要const保护d1
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day
    }
private:
    int _year;
    int _month;
    int _day;
}

int main()
{
    Date d1(2022, 1, 1);
    Date d2(d1); //拷贝构造函数调用

    return 0;
}
  3. 若未显示定义，系统默认生成的拷贝构造函数。默认的拷贝构造函数对象按内存存储字节序完成拷贝，这种拷贝叫做浅拷贝或值拷贝。

浅拷贝的问题(浅拷贝的成员指向一块空间)：

1.指向同一块空间，修改数据会互相影响。

2.这块空间析构时会释放两次，程序会崩溃。

class Stack
{
public:
	Stack(int capacity)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		_top = 0;
        _capacity = capacity;
	}
    
    //拷贝构造函数
    Stack(const Stack& st)
    {
        _a = st._a;
        _top = st._top;
        _capacity = st._capacity;
    }

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
    Stack st1(1);
    Stack st2(st1);

    return 0;
}

st1._a初始化会开辟一块空间，当st2对st1进行浅拷贝或值拷贝的时候仅仅只是将st1的地址赋值给st2._a，因此st1._a和st2._a指向内存中的同一块空间，当对象调用析构函数时，st1以及st2两个对象的析构函数都会作用于_a上，相当于_a的空间被释放了两次，程序崩溃。(需要用深拷贝实现来解决问题)

结论：一般的类，用默认生成的拷贝构造就够用了。只有像Stack这样的类，自己直接管理资源，需要自己实现深拷贝。

注意：两个已经存在的对象之间是赋值，已存在的对象与新对象之间是拷贝。

5.赋值运算符重载

5.1运算符重载

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

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

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

注意：

  • 不能通过连接其它符号来创建新的操作符：比如operator@
  • 重载操作符必须有一个类类型参数
  • 用于内置类型的运算符，其含义不能改变，例如：内置的整形+，不能改变其含义
  • 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参
  • .*  、::  、sizeof  、?:  、.  注意：以上5个运算符不能重载。
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//运算符重载
	//函数名:operator运算符
	//参数：运算符的操作数
	//返回值：运算符运算后结果
	//&引用 防止调用拷贝构造
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

	bool operator<(const Date& d)
	{
		if (_year < d._year
			|| _year == d._year && _month < d._month
			|| _year == d._year && _month == d._month && _day < d._day)
			return true;
		else
			return false;
	}

	//赋值运算符重载
	//用引用返回就不用传值返回，不会生成拷贝
	Date& operator=(const Date& d)
	{
		//防止发生像d1 = d1这样自己给自己赋值的无效操作
		if (this != &d) //这里的&d为取地址
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}

		return *this;
	}

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

int main()
{
	Date d1(2022, 1, 1);
	Date d2(2022, 1, 2);

	if (d1 == d2) // 编译器会处理成对应重载运算符调用if(d1.opreator(&d1, d2))
	{
		cout << "d1 = d2" << endl;
	}

	if (d1 < d2)
	{
		cout << "d1 < d2" << endl;
	}

	d2 = d1; // -> d2.operator(&d2, d1)

	return 0;
}

6.日期的实现

6.1Date.h

#pragma once

#include <iostream>
#include <assert.h>
using std::cout;
using std::cin;
using std::endl;

class Date
{
    friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::istream& in, Date& d);
public:

	bool isLeapYear(int year)
	{
		return ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0));
	}

	int GetMonthDay(int year, int month);

	Date(int year = 1, int month = 1, int day = 1);

	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	Date operator+(int day) const;
	Date& operator+=(int day);
	Date operator-(int day) const;
	Date& operator-=(int day);	
	int operator-(const Date& d) const;

	Date& operator++()       // 前置 ++d1 (d1.opreator++())
	{
		*this += 1;
		return *this;
	}

	//用参数来区分前置后置
	Date operator++(int)   // 后置 d1++ (d1.opreator++(0))
	{
		Date tmp(*this);
		*this += 1;

		return tmp;
	}

	Date& operator--()
	{
		*this -= 1;
		return *this;
	}

	Date operator--(int)
	{
		Date tmp(*this);
		*this -= 1;

		return tmp;
	}

	int operator-(const Date& d) const;

	bool operator==(const Date& d) const;
	bool operator<(const Date& d) const;
	bool operator>(const Date& d) const
	{
		return !(*this <= d);
	}

	bool operator>=(const Date& d) const
	{
		return !(*this < d);
	}

	bool operator!=(const Date& d) const
	{
		return !(*this == d);
	}

	bool operator<=(const Date& d) const
	{
		return *this < d || *this == d;
	}

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

6.2Date.cpp

#include "Data.h"

int Date::GetMonthDay(int year, int month)
{
	assert(year >= 0 && month < 13);

	//加static防止频繁调用开空间
	static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	if (month == 2 && isLeapYear(year))
		return 29;
	else
		return monthDayArray[month];
}

Date::Date(int year, int month, int day)
{
	if (year >= 1 &&
		month <= 12 && month >= 1 &&
		day >= 1 && day <= GetMonthDay(year, month))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout << "日期非法" << endl;
	}
}

bool Date::operator<(const Date& d) const
{
	if ((_year < d._year)
		|| (_year == d._year && _month < d._month)
		|| (_year == d._year && _month == d._month && _day < d._day))
		return true;
	else
		return false;
}

bool Date::operator==(const Date& d) const
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

Date Date::operator+(int day) const
{
	Date ret(*this);
	ret += day;

	return ret;

	/*Data ret(*this);
	ret._day += day;
	while (ret._day > GetMonthDay(ret._year, ret._month))

	{
		ret._day -= GetMonthDay(ret._year, ret._month);
		ret._month++;
		if (ret._month == 13)
		{
			ret._year++;
			ret._month = 1;
		}
	}

	return ret;*/
}

Date& Date::operator+=(int day)
{	
	//*this = *this + day;
	//return *this;
	if (day < 0)
		return *this -= -day;

	_day += day;
	while (_day > GetMonthDay(_year, _month))

	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}

	return *this;
}

Date Date::operator-(int day) const
{
	Date ret(*this);
	ret -= day;

	return ret;
}

Date& Date::operator-=(int day)
{
	if (day < 0)
		return *this += -day;
	_day -= day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}

		_day += GetMonthDay(_year, _month);
	}

	return *this;
}

int Date::operator-(const Date& d) const
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this < d)
	{
		min = *this;
		max = d;
		flag = -1;
	}

	int n = 0;
	while (min != max)
	{
		++n;
		++min;
	}

	return n*flag;
}

std::ostream& operator<<(std::ostream& out, const Date& d)
{
	out << d._year << "_" << d._month << "-" << d._day << endl;
	return out;
}

std::istream& operator>>(std::istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

7.const成员

7.1const修饰类的成员函数        

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明该成员函数中不能对类的任何成员进行修改。

8.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器会默认生成。

class date
{
public:
    Date* operator&()
    {
        return this;
    }

    const Date* operator&()const
    {
        return this;    
    }
private:
    int _year;
    int _month;
    int _day; 
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获得指定的内容。

mashirooo~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
模板初阶＜C++初阶＞(跑路人笔记)
qq_61434711的博客
06-01 247
主要讲述一下模板怎么用,以及注意事项让我们可以使用模板,后续细节会在模板进阶的时候讲到.先用一下模板给大家看看吧. 我们这个Swap函数就可以完成任何类型的调用(前提是a,b类型相同–原因后面会讲).如我们传两个int两个double我们的Swap函数都可以完美运行.来看看吧这个功能的实现其实也是很简单的我们的编译器会根据传来的类型生成一个对应类型的函数,我们先简单看一下VS的反汇编代码吧.看上面两个函数的指令我们就可以看出我们的Swap函数生产了两个.而这就是模板的主要功能:也就是说我们的模板可以无视类型
QT 之 QMutexLocker如何安全锁住全局变量
qq_40170041的博客
12-08 1322
首先需要注意的是：QMutexLocker这个类是基于QMutex的便利类，这个类不能够定义 私有成员变量 和 全局变量，只能够定义局部变量来使用。使用方法（1）先定义一个QMutex类的变量(2)在定义一个QMutexLocker类的变量（注意：在需要上锁的地方直接定义即可）使用注意：（1）如果需要对一个全局变量区域进行保护，那么QMutex定义的变量就得是全局的！解锁原理。
C++中，关于#include<***.h>和#include"***.h"的区别
简单就是美
02-17 7883
#include<>直接从编译器自带的函数库中寻找文件 #include""是先从自定义的文件中找 ，如果找不到在从函数库中寻找文件
C语言中多文件编程时重复定义的问题探究
qq_41854911的博客
07-03 7904
前几天在用几个非常简单的.c文件和.h文件模拟多文件编程时，一直在报重复定义的错误，因此为了彻底搞清楚这个问题，就决定写一篇文章来弄清C语言多文件编程中的这些问题。 下面是我看过唯一一个关于C语言多文件编程的教程：C语言头文件的编写（多文件编程） 首先我们要明确在C语言编程中的基本知识： 1、头文件：头文件的作用在于编译时，会在#include<*.h>位置处展开，所以如果有多个.c文件include同一个头文件（很常见），如果头文件编写时不进行处理，出现重复定义是不可避免的。尤其是当一个项目
数据结构笔记2
维唯为为_CSDN博客
06-27 431
1.栈 stack.h//stack.h       #ifndef _STACK_H    #define _STACK_H       #include "stack.h"    #include "data.h"       #define ElemType TREE*      
＜C++初阶＞类与对象(上)
shinamashiro_的博客
05-24 142
1.面向过程和面向对象初步认识 C语言时面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象将一件事情拆分成不同的对象，靠对象之间的交互完成。 2.类的引入 C语言中，结构体只能定义变量，在C++中结构体不仅能定义变量，也可以定义函数。 #include <iostream> #include <cstring> using namespace std; struct Student { void
＜C++初阶＞类与对象(下)
shinamashiro_的博客
07-12 198
目录1.构造函数1.1构造函数体赋值1.2初始化列表1.3explicit关键字2.static成员2.1概念2.2特性3.C++的成员初始化新玩法4.友元4.1友元函数4.2友元类5.内部类5.1概念及特性6.封装在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其作为对象成员的初始化，构造函数体中的语句只能将其作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数内可以多次赋值。初始化列表：以一
＜C++ 初阶＞ C++入门
shinamashiro_的博客
05-24 261
1.什么是C++ C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言就不适合了。为了解决软件危机，20世纪80年代，计算机界提出了OOP(object oriented programming：面对对象)思想，支持面向对象的程序设计语言诞生。 1982年，Bjarne stroustrup博士在C语言的基础上引入并扩充了面对对象的概念，发明了一种新的程序语言。为了表达该语言与C语言的渊源关系，命名为C++。C++是基于C语言而产生的，
c++中的<cstdio>实现
07-27
c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 c++中的<cstdio>实现 ...
c++中<cstdlib>的底层实现
07-27
c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 c++中<cstdlib>的底层实现 ...
c++中的<algorithm>实现
07-27
c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的<algorithm>实现 c++中的...
c++中<iostream>库的底层实现
07-27
c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++中<iostream>库的底层实现 c++...
<<易学C++>>
09-19
C++学习 上海大学教授写的 涵盖了C++语言的基本数据结构 面向对象基础 继承 多态 模板 泛型 文件 等
new/delete详解(跑路人笔记)＜C++初阶＞
qq_61434711的博客
05-29 2355
文章目录前言new/delete内置类型举例自定义类型举例new失败operator new与operator delete现式调用构造函数new和delete的实现原理malloc/free和new/delete的区别小结 前言 new和delete是C++为了类的使用方便而创造的操作符,我们在使用C++时应该尽量避免使用malloc和free而应该转向使用new和delete. new/delete 内置类型举例 new/delete类似于malloc/free但是为了搭配我们的C++的新知识也就是类的
C++之模板（四）
CSDN_HZW的博客
06-18 259
【代码】C++之模板（四）
C++ day3
2301_81402136的博客
06-17 282
【代码】C++ day3。
【C++】类的六个默认成员函数
最新发布
炸掉地球的博客
06-21 659
C++类的六个默认构造函数。
设计一个money类，包含有元，角，分，能实现+、<<、>>三种运算符的重载c++
06-02
好的，下面是一个可以实现+、<<、>>三种运算符重载的Money类的设计（C++实现）： ```c++ #include <iostream> class Money { public: Money(int yuan = 0, int jiao = 0, int fen = 0) { this->yuan = yuan; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值