类与对象（二）

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量694 收藏 19
点赞数 21
分类专栏： # 必须掌握的C++基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53903743/article/details/135911616
版权
文章详细讲解了C++中的默认成员函数，包括构造函数（无参写法、重载）、析构函数、拷贝构造函数（值传递与浅拷贝问题）、赋值运算符重载（包括=、>、!=、<）、const成员以及取地址和const取地址操作符重载。
摘要由CSDN通过智能技术生成

目录

类的默认成员函数

类中共有6个默认成员函数，即自己不实现，编译器会帮助我们实现出来。构造函数、析构函数、拷贝构造、赋值运算符重载、const成员、取地址及const取地址操作符重载。
在这里插入图片描述

一. 构造函数

1. 概念

在对象构造时调用的函数，这个函数完成初始化工作

2.无参时主函数中的写法


#include<iostream>
using namespace std;
class date
{
public:
    //没有返回值
    date(int year, int month, int day)//构造函数名与类名相同
    {
        _year = year;
        _month = month;
        _day = day;
    }
    date()//构造函数可以重载
    {
        _year = 0;
        _month = 0;
        _day = 0;
    }
    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

    int main()
    {
    //构造函数无参时
        //date d();错误写法会报错
        date d;//正确写法
        d.print();
        return 0;
    }

构造函数无参是一种特殊情况，不能像普通成员函数一样写括号，只写类的实例化即可。编译器无法区分 date d(); 是函数的声明还是定义对象

3. 特性

特性1-3
1.没有返回值
2.函数名跟类名相同
3.对象实例化时编译器自动调用对应的构造函数

#include<iostream>
using namespace std;
class date
{
  public:
  //没有返回值
  date(int year,in tmonth,int day)//构造函数名与类名相同
  {
   _year=year;
   _month=month;
   _day=day;
   }
   private:
   int _year;
   int _month;
   int _day;
   
int main()
{
date d(2023,2,7);//类的对象实例化自动调用构造函数
return 0;
}

特性 4
4.构造函数可以重载(一个类有多个构造函数)

class date
{
  public:
  //没有返回值
  date(int year,in tmonth,int day)//构造函数名与类名相同
  {
   _year=year;
   _month=month;
   _day=day;
   }
   date ()//构造函数可以重载
   {
    ....
    }
   private:
   int _year;
   int _month;
   int _day;
   
int main()
{
date d(2023,2,7);//类的对象实例化调用构造函数
return 0;
}

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

#include<iostream>
using namespace std;
class date
{
public:
	//编译器自动生成默认构造函数
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
		int _year;
		int _month;
		int _day;
};
int main()
{
	date d;
	d.print();//-858993460--858993460--858993460
	return 0;
}

若输出结果，则会发现为随机值对于编译器自动生成的默认构造函数， 针对内置类型的成员变量没有做处理。

自定义类型

#include<iostream>
using namespace std;
class Time
{
public:
	Time()//默认构造函数
	{
		_hours = 0;
		_minute = 0;
		_seconds = 0;
	}
private:
	int _hours;
	int _minute;
	int _seconds;
};
class date
{
public:
	//没有构造函数，则编译器会自动生成一个无参的默认构造函数
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;//调用自定义类型
};
int main()
{
	date d;//无参数
	d.print();
	return 0;
}

特性 6
无参的构造函数和全缺省的构造函数都被称为默认构造函数，并且默认构造函数只能有一个对于无参的，两者都可以使用，就没必要共同存在默认构造函数：(不用传参数)
1.自己实现的无参的构造函数
2.自己实现的全缺省构造函数
3.自己没写编译器自动生成的

  • 既想要带参数，又想要不带参数的 如何使用一个构造函数完成？
    全缺省若参数没有传过去，则使用缺省参数。若有参数，则直接进入函数中。
#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, 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 d;//无参数
	d.print();//1-1-1
	date d2(2022, 12, 20);//带参数
	d2.print();//2022-12-20
	return 0;
}

二.析构函数

1. 概念

对象在销毁时会自动调用析构函数，完成类的一些资源清理工作

2. 特性

析构函数名是在类名前加上字符~ (~在c语言表示按位取反)
无参数无返回值类型。
一个类只能由一个析构函数，若未显式定义，系统会自动生成默认的析构函数(析构函数不能重载)。
对象生命周期结束，C++编译系统自动调用析构函数。

#include<iostream>
using namespace std;
class date
{
public:
date()
{
}
//没有返回值并且无参
~date()//析构函数,若我们自己不写，系统会自动生成一个析构函数
{
}
int main()
{
date d;
 return 0;//调试时，走到return 0这步 F11会进入析构函数
 }

三.拷贝构造函数

1.值传递

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//全缺省构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	date(date d)//值传递  date d 会报错造成无限循环
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1(2022,12,21);
	date d2(d1);//拷贝构造
	return 0;
}

2.浅拷贝问题

#include<iostream>
using namespace std;
class stack
{
public:
	stack(int n)//构造函数
	{
		 _a = (int*)malloc(sizeof(int) * n);
		 _size = 0;
		 _capity = n;
	}
	~stack()//析构函数
	{
		free(_a);
		_a = nullptr;
		_size = _capity = 0;
	}

private:
	int * _a;
	int _size;
	int _capity;
};
int main()
{
	stack s1(10);
	stack s2(s1);//拷贝构造
	return 0;//空间会被释放两次，程序崩溃
}

四.赋值运算符重载

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, 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,12,21);
	date d2(2022,12,22);
	return 0;
}

date 实例化出的对象 d1 与d2 的大小可以直接比较嘛？
不可以，内置类型是编译器自己定义的类型，它知道要怎么比
自定义类型是自己定义的，怎么比较大小由自己规定。C++为了增强代码的可读性引入运算符重载，运算符重载是具有特殊函数名的函数 ，运算符重载就是为了给自定义类型进行比较等提供的函数。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)。

1. 操作符 ==

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator ==( const date& d2)// 由于隐藏的this指针的存在，&d1传过来由this指针接收
	{
		return _year == d2._year && _month == d2._month && _day == d2._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	date d1(2022,12,21);
	date d2(2022,12,22);
	d1 == d2;//  d1.operator==(d2) 等价于 d1.operator==(&d1,d2)
	cout << (d1 == d2) << endl;
	return 0;
}

传入类中，由于隐藏的this指针的存在，取第一个参数d1的地址传过去被this指针接收，_year等价于d1._year。但是由于this指针是隐藏的，所以&d1也不需要表现出来直接传入d2即可

注意事项
1.不能通过连接其他符号来创建新的操作符 (如 operator@）
2.重载操作符必须有一个类类型参数
3.用于内置类型的操作符，其含义不能改变(如 int 加法 不能改变)

这里理解很简单，因为运算符重载是针对自定义类型的，对于内置类型，编译器都已经设置好了
4.作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的操作符有一个默认的形参this，限定为第一个形参

2. 操作符 >

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator >( const date& d2)// 由于隐藏的this指针的存在，&d1传过来由this指针接收
	{
		if (_year > d2._year)//年大为大
		{
			return true;
		}
		else if (_year == d2._year && _month > d2._month) //年相等，月大为大
		{
			return true;
		}
		else if (_year == d2._year && _month == d2._month && _day > d2._day)//年 月相等，天大为大
		{
			return true;
		}
		else
		{
			return false;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	date d1(2022,12,21);
	date d2(2022,12,22);
	d1 > d2;//等价于 operator>(&d1,d2)
	cout << (d1 > d2) << endl;
	return 0;
}

3. 操作符 !=

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator==(const date& d2)//d1==d2
	{
		return _year == d2._year && _month == d2._month && _day == d2._day;
	}
	bool operator!=(const date& d2)
	{
		return !(*this == d2);//借助上面的d1==d2的相反即 d1!=d2
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1(2022,12,21);
	date d2(2022,12,22);
	d1 != d2;
	cout << (d1 != d2) << endl;
	return 0;
}

4. 操作符 <

#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator >(const date& d2)// d1>d2
	{
		if (_year > d2._year)//年大为大
		{
			return true;
		}
		else if (_year == d2._year && _month > d2._month) //年相，月大为大
		{
			return true;
		}
		else if (_year == d2._year && _month == d2._month && _day > d2._day)//年 月相等，天大为大
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	bool operator<(const date& d2)// d1 < d2
	{
		return !(*this > d2);
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1(2022,12,21);
	date d2(2022,12,22);
	d1 < d2;
	cout << (d1 < d2) << endl;
	return 0;
}

5 .赋值操作符(编译器默认实现)

  1. 正常使用
#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void operator=(const date& d2)
	{
		//为了防止自己给自己赋值的事情发生，如:d1=d1
		if ( this != &d2)
		{
			_year = d2._year;
			_month = d2._month;
			_day = d2._day;
		}
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	date d1(2022,12,21);
	date d2(2022,12,22);
	d1 =d2;
	return 0;
}
  1. 连续赋值情况的考虑
#include<iostream>
using namespace std;
class date
{
public:
	date(int year = 1, int month = 1, int day = 1)//构造
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	date operator=(const date& d)//传值返回 类型为date
	{
		//为了防止自己给自己赋值的事情发生，如:d1=d1
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
	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, 12, 21);
	date d2(d1);
	date d3;
	d2 = d3 = d1;
	int i = 0;
	int j = 0;
	int z = 0;
	i = j = z;
	return 0;
}

五. const成员

1.对象调用const成员函数

#include<iostream>
using namespace std;
class date
{
public:
	void print()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	const date a;
	a.print();//权限放大，会报错
	return 0;
}

将&a传过去由this指针接收， a指针类型为 const date* ，this指针类型为 date* ，将const date * 传给date * 属于权限的放大。
把this指针类型改成 const date* 就可以了，但是由于this指针是隐藏的，要怎么解决呢？。

#include<iostream>
using namespace std;
class date
{
public:
	void print()const //this指针类型变为const date*
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	const date a;
	a.print();//正确 权限保持
	return 0;
}

const 在左右对于指针的影响
const date p1 ： 修饰的是* p1, const在 * 左面 指针所指向的内容不变
date const * p2 : 修饰的是* p2，const在* 左面 指针所指向的内容不变
date * const p3 : 修饰的是 p3，const在 * 右面，指针本身不变
6.取地址及const取地址操作符重载

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

#include<iostream>
using namespace std;
class date
{
public:
	date* operator&()
	{
		return this;
	}
	const date* operator&()const
	{
		return this;
	}
};
int main()
{
	date d;
	cout << &d << endl;
	return 0;
}
英雄哪里出来_
关注
  • 21
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
本科课程【java程序设计】实验2 - 类与对象编程练习
1+1=王的博客
04-30 6129
大家好，我是【1+1=王】， 热爱java的计算机（人工智能）渣硕研究生在读。 如果你也对java、人工智能等技术感兴趣，欢迎关注，抱团交流进大厂！！！ Good better best, never let it rest, until good is better, and better best. 近期会把自己本科阶段的一些课程设计、实验报告等分享出来，供大家参考，希望对大家有帮助。 博客更新至专栏【课程设计实验报告】：https://blog.csdn.net/weixin_43598687/ca.
java类与对象实验报告心得体会_java类和对象实验报告(共10篇)
weixin_39941847的博客
12-19 4282
java类和对象实验报告(共10篇) 为了适应公司新战略的发展，保障停车场安保新项目的正常、顺利开展，特制定安保从业人员的业务技能及个人素质的培训计划java类和对象实验报告共10篇JAVA程序设计实验报告学生学号班级专业实验六3实验目的.3实验要求.3实验基本内容.3题目一.3题目二.6题目三构造一个矩形类Rectangle，包含求矩形周长和面积的方法.6实验小结.7实验目的理解面向对象的基本概...
Java类和对象 详解（一）
热门推荐
wei_zhi的博客
10-06 18万+
一、面向对象简述面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实
Python 类与对象
zcx1203的博客
04-10 6万+
类与对象的理解与封装特性 面向对象编程语言 - 类: 一个模板, (人类)---是一个抽象的， 没有实体的 - 对象: (eg: 张三， 李四) - 属性: (表示这类东西的特征, 眼睛， 嘴巴， 鼻子) - 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习) 1). 定义类:class: 类 from collections import Count...
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
类与对象的关系
zy2317878的博客
09-03 1万+
写在前面 简单记录一下类与对象的关系，问题不难，但觉得还是写出来，会帮助自己记忆更牢固，而且万一以后有需要，可以及时回顾。 参考文献： 类与对象的区别 Java类和对象 详解（一） Java类和对象 详解（二） 声明对象、类与对象的区别 类和对象的区别 基础概念 1.类 简单来说：类是抽象的，是对对象的抽象。 具体来说：类是对现实生活中一类具有共同特征的事物的抽象，实质是一种...
C++面向对象实验二：类与对象
重口味码农
11-24 5705
C++实验二：类与对象一、实验目的 类的创建和使用类来创建对象。 类的数据成员的声明。 成员函数的声明和定义。 Private，public访问限定符的使用。 使用提供的公有的成员函数给对象成员赋值。 二、实验要求类：包含私有的数据成员（length，wide）和公有的成员函数（重载的构造函数oneclass，求和函数add，输出显示函数（display）。三、实验过程描述了一个圆柱的类，成员中有私
java类与对象实验报告心得体会_Java类与对象实验报告
weixin_39727336的博客
12-19 3531
实验报告一、实验项目：类与对象二、实验目的：1.学会使用类来封装对象的属性和功能2.掌握类变量与实例变量，以及类方法与实例方法的区别3.掌握使用package和import语三、实验器材：计算机、Java编程软件JCreator四、实验原理(或仪器装置图)：1.类与对象类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。类声明class类名{类体}对象的声明一般格...
C++类对象进行排序
taoxing
08-29 4957
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
Java基础——类和对象
explorer363的博客
04-26 3万+
本篇博客介绍了Java中类和对象的基本内容，看完本篇博客后，希望大家能对类和对象能有进一步的了解
二_类与对象_
10-03
在编程世界中，类与对象是面向对象编程（OOP）的核心概念。面向对象编程是一种设计和实现软件的方法，它基于“对象”的概念，而这些对象则是类的实例。类可以看作是创建对象的蓝图，它定义了对象的数据属性和行为。...
java实验报告类与对象
04-22
在实验中，我们没有直接使用数组，但是我们使用了对象数组对 Customer 类对象进行存储。在 Cmanage 类中，我们可以使用对象数组来存储多个 Customer 对象，并提供了插入、修改、删除、查询等操作。 三、掌握 Java ...
类与对象-java实验报告
06-22
本次实验的目的是深入理解和掌握Java编程语言中的类与对象的概念，通过设计和实现一系列几何图形类，包括点、直线、三角形、矩形、正方形、圆形和椭圆，来实践面向对象的设计方法。实验要求学生不仅能够创建数据域和...
C#实验报告类与对象实验项目
07-07
在本C#实验报告中，我们探讨了类与对象的核心概念，这是面向对象编程的基础。实验的主要目的是理解和掌握C#程序的设计与编写流程，以及如何运用面向对象的思维方式。通过这个实验，我们可以深入学习以下几个关键知识...
实验3--类与对象.doc
02-15
二是设计一个角色类，描述角色之间的决斗，包括交手次数、经验值和生命值之间的关系。 首先，关于"复数"类，学生需要定义一个包含实部和虚部的数据成员，并实现复数之间的加减运算。这涉及到定义构造函数来初始化...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1175
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 471
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 228
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
淘客返利系统中的服务发现与注册机制详解
技术研究中心
07-22 1933
通过服务注册中心，服务提供者可以将自己注册到注册中心，服务消费者可以从注册中心获取服务提供者的地址，以实现服务调用。本文详细介绍了淘客返利系统中服务发现与注册机制的实现，包括Eureka的配置与代码示例。通过Eureka，我们可以轻松实现服务的注册与发现，确保分布式系统中各个服务之间的通信。在本文中，我们将深入探讨淘客返利系统中的服务发现与注册机制，并结合Java代码进行详细讲解。在我们的淘客返利系统中，我们采用Eureka作为服务发现与注册的工具。在我们的淘客返利系统中，首先需要配置Eureka服务器。
c++类与对象二实验
12-14
c类和对象是面向对象编程中非常重要的概念，它们允许我们将数据和功能结合起来，以便更好地组织和管理代码。在c语言中，类和对象可以通过结构体和指针来实现。 首先，我们可以使用结构体来定义类，结构体可以包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值