缺省参数+函数重载+构造函数+运算符重载

已于 2023-09-24 17:17:35 修改
阅读量1.3k 收藏 11
点赞数 7
分类专栏： 面向对象编程c++ c++ 文章标签： c++
于 2023-02-10 14:34:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/128968410
版权

目录

 一、缺省参数

（一）缺省参数概念

（二）缺省参数分类

1. 全缺省参数

2.  半缺省参数（缺省部分参数）

3. 注意

二、函数重载

（一）基本概念

（二）举例

三、构造函数基本概念

四、构造函数特性

（一）特征 

1. 函数名与类名相同

2. 无返回值（void也不行）

3. 对象实例化时编译器自动调用对应的构造函数

4. 构造函数可以重载 

（二）举例：不利用构造函数初始化对象

（三）举例：利用构造函数初始化对象

（四）举例

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

2. 一旦用户显式定义编译器将不再生成

3. 解决调用默认构造函数的方法

（五）单参数构造函数隐式类型转换

五、注意

六、运算符重载

 一、缺省参数

（一）缺省参数概念

  • 缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参
#include<iostream>
using namespace std;
void test(int a=1)
{
	cout << a << endl;
}
int main()
{
	test(11);//11
	test();//1
	return 0;
}

（二）缺省参数分类

1. 全缺省参数

#include<iostream>
using namespace std;
void test(int a = 1, int b = 2, int c = 3, int d = 4)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
	cout << endl;
}
int main()
{
	test();//a,b,c,d都使用缺省的
	return 0;
}

2.  半缺省参数（缺省部分参数）

#include<iostream>
using namespace std;
void test(int a,int b=2,int c=3,int d=4)
{
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << "d = " << d << endl;
	cout << endl;
}
int main()
{
	test();//a,b,c,d都使用缺省的
	test(11);//给a传参，b、c、d使用缺省的
	test(11,22);//给a、b传参，c和d使用缺省的
	test(11, 22, 33);

	return 0;
}

3. 注意

  • 半缺省参数必须从右往左依次来给出，不能间隔着给（也就是调用时，传参从左向右依次传参，不能空缺）
  • 缺省参数不能在函数声明和定义中同时出 

二、函数重载

（一）基本概念

  • 是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题 

（二）举例

#include<iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}


// 2、参数个数不同
void test()
{
	cout << "test()" << endl;
}
void test(int a)
{
	cout << "test(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}
int main()
{
	Add(1, 2);
	Add(1.4, 5.7);

	test();
	test(66);

	f(11, 'a');
	f('a', 16);
	return 0;
}

 

三、构造函数基本概念

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

四、构造函数特性

  • 构造函数的主要任务并不是开空间创建对象，而是初始化对象

（一）特征 

1. 函数名与类名相同

2. 无返回值（void也不行）

3. 对象实例化时编译器自动调用对应的构造函数

4. 构造函数可以重载 

（二）举例：不利用构造函数初始化对象

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	void Init(int year, int month, int day)//定义初始化函数
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()//打印函数
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;
	d1.Init(2022, 8, 9);
	d1.Print();//2022-8-9
	return 0;
}

（三）举例：利用构造函数初始化对象

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()//打印函数
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1(2022, 8, 9);//对象实例化时，自动调用构造函数
	d1.Print();//2022-8-9
	return 0;
}

（四）举例

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

//举例1：类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数
#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	void Print()//打印函数
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;//d1调用系统生成的无参构造函数
	d1.Print();
	return 0;
}

2. 一旦用户显式定义编译器将不再生成

3. 解决调用默认构造函数的方法

  • 第一种调用系统默认的无参构造函数
  • 第二种自己实现无参构造函数

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:
	Date()
	{
		_year=0;
		_month = 1;
		_day = 2;
	}
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()//打印函数
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;
	d1.Print();

	Date d2(2022, 9, 14);
	d2.Print();
	return 0;
}
  • 第三种利用全缺省的构造函数

 

#include<iostream>
using namespace std;
class Date
{
private:
	int _year;
	int _month;
	int _day;
public:

	Date(int year=2021, int month=1, int day=8)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()//打印函数
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
};
int main()
{
	Date d1;
	d1.Print();

	Date d2(2022, 9, 14);
	d2.Print();
	return 0;
}

（五）单参数构造函数隐式类型转换

#include<iostream>
using std::cout;
using std::endl;
class A
{
public:
	A(int a = 77) :_a(a)
	{
		cout << "A()" << endl;
	}

	A(const A& o)
	{
		cout << "A(const A& ) " << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
	void Print()const
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	//有名对象
	A a1(1);

	A a2 = 3;

	const A& a3 = 4;

	cout << "a1：";
	a1.Print();

	cout << "a2：";
	a2.Print();

	cout << "a3：";
	a3.Print();
}

五、注意

  • 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数

六、运算符重载

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

日期类的实现

//Date.h
#pragma once
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
using std::ostream;
using std::istream;

class Date
{
public:
	friend void operator<<(ostream& out,const Date& d);//重载<<(out是cout的别名)
	friend void operator>>(istream& in, Date& d);//重载>>


	Date(int y = 1, int m = 2, int d = 3);
	Date(const Date& d);
	bool operator<(const Date& d)const;
	bool operator==(const Date& d)const;
	bool operator<=(const Date& d)const;
	bool operator>(const Date& d)const;

	int GetDay(int y, int m) const;//获取某一年某月的天数
	Date& operator+=(int d);
	Date operator+(int d)const;

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

	Date& operator++();//前置++
	Date operator++(int);//后置++（使用int参数进行占位）

	void Print()const;

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


//Date.cpp
#include"Date.h"
Date::Date(int y, int m, int d)
{
	_year = y;
	_month = m;
	_day = d;
}

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

bool Date::operator<(const Date& d) const
{
	if (_year < d._year)
		return true;
	if (_year == d._year and _month < d._month)
		return true;
	if (_year == d._year and _month < d._month and _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;
}

bool Date::operator<=(const Date& d) const
{
	return *this < d || *this == d;//此处相当于直接调用上面定义过的
}

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

int Date::GetDay(int y, int m) const
{
	static int a[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	if (m == 2)//某年是闰年的时候，2月为29
	{
		if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
		{
			return 29;
		}
	}

	return a[m];
}

Date& Date::operator+=(int d)
{
	_day += d;
	while (_day > GetDay(_year, _month))
	{
		_day -= GetDay(_year, _month);
		++_month;

		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}
	return *this;
}

Date Date::operator+(int d) const
{
	Date tmp;
	tmp = *this;

	tmp._day += d;
	while (tmp._day > GetDay(tmp._year, tmp._month))
	{
		tmp._day -= GetDay(tmp._year, tmp._month);
		++tmp._month;

		if (tmp._month == 13)
		{
			tmp._year++;
			tmp._month = 1;
		}
	}
	return tmp;
}

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

Date Date::operator-(int d) const
{
	Date tmp(*this);
	tmp._day = tmp._day - d;
	while (tmp._day <= 0)
	{
		--tmp._month;
		if (tmp._month == 0)
		{
			--tmp._year;
			tmp._month = 12;
		}

		tmp._day += GetDay(tmp._year, tmp._month);
	}

	return tmp;
}

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

Date Date::operator++(int)//后置++
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}

void Date::Print() const
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

void operator<<(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日";
}

void operator>>(istream& in, Date& d)//重载>>
{
	in >> d._year >> d._month >> d._day;
}

//test.cpp
#include"Date.h"
int main()
{
	Date d1(2021, 11, 25);
	d1 += 1000;
	cout << "d1：";
	d1.Print();//2024年8月21日
	cout << endl;


	cout << "d2：";
	Date d2 = d1 + 60;
	d2.Print();//2024年10月20日
	cout << endl;


	cout << "d2：";
	d2 -= 1068;
	d2.Print();//2021年11月17日
	cout << endl;


	cout << "d3：";
	Date d3 = d2 - 800;
	d3.Print();//2019年9月9日 
	cout << endl;


	cout << "d4：";
	Date d4 = d1;
	++d4;
	d4.Print();
	cout << endl;

	cout << "d5：";
	Date d5 = d1;
	d5++;
	d5.Print();
	cout << endl;


	cout << "<<重载：" << endl;
	cout << d1;
	cout << endl;


	cout << ">>重载：" << endl;
	Date d6;
	cin >> d6;
	cout << d6;
	return 0;
}

莫忘、莫念
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++中构造函数的参数缺省的详解
12-31
C++中构造函数的参数缺省的详解 前言： 构造函数中参数的值既可以通过实参传递，也可以指定为某些默认值，即如果用户不指定实参值，编译系统就使形参取默认值。在构造函数中也可以采用这样的方法来实现初始化。 #include using namespace std; class A { public : A(int aa=0,int bb=00); //在声明构造函数时指定默认参数 int volume( ); int a; int b; }; int main( ) { A obj(4); cout<<obj.a<< <<obj.b; retur
缺省构造函数
longj's coding workbench
03-03 3287
第4章：初始化与清除 本篇博客主讲 缺省构造函数
C++之缺省参数的构造函数、缺省的构造函数及缺省的析构函数
10-31 8149
缺省参数的构造函数 一、对于带参数的构造函数，在定义对象时必须给构造函数传递参数，否则构造函数将不被执行。         但是在实际应用中，有些构造函数的参数值通常是不变的，只有在特殊情况下才需要改变它的参数值，这时可以定义成带参数的构造函数。 示例： class Stu { private: char *name,*stu_no; float score;
C++缺省参数的函数
程伟康的博客
05-16 9701
C++缺省参数的函数 定义：C++在声明函数原型时，可为一个或多个参数指定缺省参数值，以后调用此函数，若省略其中某一参数，C++自动地以缺省值作为相应参数的值。 例如函数原型说明为：  int add(int x=15,float y=20.56);  当进行函数调用时，可以有以下几种形式：  1)  add(100,79.8); // x=100,y=79.8  2) 
C++缺省参数函数简介和使用
热门推荐
阿海的博客
12-14 2万+
C++缺省参数函数简介和使用
C++基础：缺省构造函数
weixin_30735391的博客
05-10 3406
缺省构造函数，又称默认构造函数，是C++以及其他的一些面向对象的程序设计语言中，对象的不需要参数即可调用的构造函数。下面将针对缺省构造函数的定义、使用、以及注意问题等方面简要探讨。 1、缺省构造函数是怎样的形式？是如何定义的？ 在C++的一个类中，如果构造函数没有参数，或者构造函数的所有参数都有默认值，就可以称其为缺省构造函数。一个类中...
构造函数的重载
qq_45288949的博客
04-29 5709
（一）重载函数条件 (1)函数名相同 (2）函数参数不同（一下两个满足其中一个即可） 1）函数参数个数不同 2）函数参数类型不同 注意：函数返回值不同不能作为函数重载条件 重载：根据函数参数个数和参数数据类型来自动调用哪一个重载函数 （二）构造函数的重载 1）默认/缺省构造函数 （1）如果没有构造函数，系统会提供一个默认的构造函数帮助创建对象 （2）默认构造函数没有参数 2）复制/拷贝构造函数 用对象初始化另一个对象，需要用到复制构造函数 （1）作用：用一个已知的对象初始化另一
C++：构造函数和析构函数
杜恒其的博客
04-15 1148
 在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。 构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。 构造函数没有返回值，因为没有变量来接收返回值，即使有也
C++基础构造函数入门
TT_run的博客
07-25 636
构造函数一看就会
关于C++缺省构造函数的讲解——精解
ThinPikachu的博客
03-15 1万+
构造函数 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行， 构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。 在这里有几点要注意的问题： 构造函数在实例化对象时自动被调用，且在每个对象的生命期仅被调用一次。 可以被重载。 若程序员没有主动给类定义构造函数，编译器自动给一个缺省的构造函数。 一旦程序员定...
C++构造函数初始化顺序详解
01-01
2.缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都初始化为零或空 3.创建一个对象时，系统自动调用构造函数 析构函数 1.析构函数没有参数，也没有返回值。不能重载，也...
ThinkingC++
07-30
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
C++编程思想（ThinkinginC++ ）
04-15
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
ThinkingC++,C++学习书籍
08-11
全书共分十八章，内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚...
【C++第三阶段】list容器&排序
还有很多需要学习，现在还很菜
04-29 611
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
C 练习实例36 - 求100之内的素数
2401_82561004的博客
04-27 991
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
C++类型转换攻略
最新发布
无敌岩雀的博客
04-30 1463
在C++编程中，类型转换（Type Conversion）是一个核心概念，它指的是将一个数据类型的值转换为另一个数据类型的值的过程。这种转换可能是隐式的（由编译器自动执行），也可能是显式的（由程序员通过特定的语法明确指示）。类型转换在编程中至关重要，因为它允许程序员灵活地处理不同数据类型的数据，并能够在需要时将它们转换为兼容的类型，以便进行进一步的计算或操作。
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 231
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
每日一题 —— 图像渲染
学习C++的小陈同学
04-26 296
简单总结一下，用C++写的，这题算是dfs过渡到FloodFill算法的一题
具有缺省参数的构造函数
04-25
在C++中，可以通过在函数声明时使用"="号来指定缺省参数，例如: ```c++ class Example { public: int age; Example(int a = 18) { age = a; } }; int main() { Example e1; //不传任何参数，age默认为18 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值