类和对象(再谈构造函数)

news2024/11/15 6:00:40

文章目录

  • 1.再谈构造函数
    • 1.1构造函数的赋值
    • 1.2初始化列表
    • 1.3 explicit关键字
  • 2. static成员
    • 2.1概念
    • 2.2特性
    • 2.3例题
  • 3 .友元
    • 3.1 友元函数
    • 3.2友元类
  • 4.内部类
  • 5.匿名对象
  • 6.拷贝对象时编译器的一些优化

1.再谈构造函数

1.1构造函数的赋值

在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量的初始化,构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值

1.2初始化列表

初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。

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

【注意】

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员,必须放在初始化列表位置进行初始化:
    (1)引用成员变量
    (2)const成员变量
    (3)自定义类型成员(且该类没有默认构造函数时)
class A
{
public:
	A(int x)
		:_a(x)
	{

	}
private:
	int _a;
};
class B
{
public:
	B(int ret)
		:b(10)
		,ret(ret)
		,a(10)
	{

	}
private:
	const int b;//const成员变量
	int& ret;//引用成员变量
	A a;//自定义类型成员(且该类没有默认构造函数时)

};
  1. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,
    一定会先使用初始化列表初始化。
class Time
{
public:
	Time(int hour = 0)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date(int day)
	{}
private:
	int _day;
	Time _t;
};
int main()
{
	Date d(1);
}

在这里插入图片描述
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后
次序无关

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}

	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};
int main() {
	A aa(1);
	aa.Print();
}

程序运行结果
在这里插入图片描述
显然是先对a2初始化,被赋值为随机值,然后a1初始化

1.3 explicit关键字

构造函数不仅可以构造与初始化对象,对于单个参数或者除第一个参数无默认值其余均有默认值
的构造函数,还具有类型转换的作用

class Date
{
public:
// 1. 单参构造函数,没有使用explicit修饰,具有类型转换作用
	//Date(int year)
	//	:_year(year)	
	//{

	//}
// 2. 虽然有多个参数,但是创建对象时后两个参数可以不传递,没有使用explicit修饰,具
有类型转换作用
	Date(int year, int month=10, int day=1) 
		:_year(year)
		,_month(month)
		,_day(day)
	{
		
	}
	Date(const Date& d)
		:_year(d._year)
		, _month(d._month)
		, _day(d._day)
	{

	}
	void print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	//单参数构造函数 c++98
	Date d1(2002);//构造函数
	d1.print();
	Date d2 = 2003;//隐式类型转换   构造+拷贝+优化->构造
	const Date& ref = 2001;//这里必须使用const恰恰应证了编译器做出优化,证明出现了临时
	//变量,用了构造函数再拷贝给ref,临时变量不可以被修改
	
	
	//多参数构造函数  c++11
	Date d3(2002, 1, 1);
	d3.print();
	Date d4 = { 2002,1,1 };
	d4.print();
	const Date& ref = { 2002,1,1 };

}

2. static成员

2.1概念

声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数****。静态成员变量一定要在类外进行初始化

面试题:实现一个类,计算程序中创建出了多少个类对象

class A
{
public:
	A(int a = 0)
	{
		++count;
	}

	A(const A& aa)
	{
		++count;
	}

	// 静态成员函数 -- 没有this指针
	static int GetCount()
	{
		// _a++; // 不能直接访问非静态成员
		return count;
	}
private:
	// 不属于某个对象,所于所有对象,属于整个类
	static int count; // 声明
	int _a = 0;
};	
int A::count = 0;
int main()
{
	cout << A::GetCount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetCount() << endl;
}

2.2特性

  1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
  2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
  3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
  4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
  5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制

静态成员函数不可以调用非静态成员函数
非静态成员函数可以调用类的静态成员函数

2.3例题

在这里插入图片描述

class sum
{
public:
    sum()
    {
        _sum += i;
        i++;
    }

    static int getsum()
    {
        return _sum;
    }
private:
    static int i;
    static int _sum;
};
int sum::i = 1;
int sum::_sum = 0;
class Solution {
public:
    int Sum_Solution(int n)
    {
        sum* ptr = new sum[n];
        return sum::getsum();
    }
};

3 .友元

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
友元分为:友元函数友元类

3.1 友元函数

问题:现在尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决operator>>同理。

class Date
{
public:
Date(int year, int month, int day)
  : _year(year)
  , _month(month)
  , _day(day)
{}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this,所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
{
  _cout << _year << "-" << _month << "-" << _day << endl;
  return _cout;
}
private:
int _year;
int _month;
int _day;
};

友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}

说明
友元函数可访问类的私有和保护成员,但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明,不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

3.2友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
1.友元关系是单向的,不具有交换性。
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
2.友元关系不能传递
如果C是B的友元, B是A的友元,则不能说明C时A的友元。
3.友元关系不能继承

class Time
{
 friend class Date;  // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类
中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
   : _year(year)
   , _month(month)
   , _day(day)
 {}
 void SetTimeOfDate(int hour, int minute, int second)
 {
   // 直接访问时间类私有的成员变量
   _t._hour = hour;
   _t._minute = minute;
   _t._second = second;
 }
private:
 int _year;
 int _month;
 int _day;
 Time _t;
};

4.内部类

概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意:内部类就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员但是外部类不是内部类的友元
特性:

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类,和内部类没有任何关系。

上面2.3例题我们同样可以用内部类解决


class Solution {
public:
    int Sum_Solution(int n) 
    {
        sum a[n];
        return sum::getsum();

    }
    class sum
    {
    public:
    sum()
    {
        _sum+=i;
        i++;
    }

    static int getsum()
    {
        return _sum;
    }

};
private:
    static int i;//这里做修改是因为内部类是外部类得友元可以访问
    static int _sum;
};

int Solution::i=1;
int Solution::_sum=0;

5.匿名对象

class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A()" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
    void print()
    {
        cout << _a << endl;
    }
private:
    int _a;
};
int main()
{
    A aa1();
    //不能这么定义对象,因为编译器无法识别下面是一个函数声明,还是对象定义
    A();
 // 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,
// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数
    return 0;
}

在这里插入图片描述
在这里插入图片描述

class sum
{
public:
    sum()
    {
        _sum += i;
        i++;
    }

    static int getsum()
    {
        return _sum;
    }
private:
    static int i;
    static int _sum;
};
int sum::i = 1;
int sum::_sum = 0;
class Solution {
public:
    int Sum_Solution(int n)
    {
        sum* ptr = new sum[n];
        return sum::getsum();
    }
};
int main()
{
    cout << Solution().Sum_Solution(10) << endl;
    //匿名对象在这情况下就很好用
    return 0;
}

6.拷贝对象时编译器的一些优化

class A
{
public:
    A(int a = 0)
        :_a(a)
    {
        cout << "A(int a)" << endl;
    }
    A(const A& a)
        :_a(a._a)
    {
        cout << "A(const A& a)" << endl;
    }
    A& operator =(const A& a)
    {
        cout << "A& operator=(const A& a)" << endl;
        if (this != &a)
        {
            _a = a._a;
        }
        return *this;
    }

    ~A()
    {
        cout << "~A()" << endl;
    }
 
private:
    int _a;
};
void func1(A aa)
{

}
void func2(const A& aa)
{

}
A func3()
{
    A aa;
    return aa;
}
A func4()
{
    return A();
}

int main()
{
    cout << "值传递" << endl;
    A a1=1;//构造+拷贝构造+优化-》直接构造
    cout << "----------------------------" << endl;
    func1(a1);//无优化
    cout << "----------------------------" << endl;
    func1(2); //构造 + 拷贝构造 + 优化 - 》直接构造
    cout << "----------------------------" << endl;
    func1(A(3));//构造 + 拷贝构造 + 优化 - 》直接构造
    cout << "----------------------------" << endl;
   
    
    
    
    cout << "引用传递" << endl;
    cout << "----------------------------" << endl;
    func2(a1);//无优化
    cout << "----------------------------" << endl;
    func2(2); //无优化
    cout << "----------------------------" << endl;
    func2(A(3));//无优化
    cout << "----------------------------" << endl;
   
    
    
    
    cout << "传值返回" << endl;
    func3();
    cout << "----------------------------" << endl;
    cout << "传值返回用拷贝构造接收" << endl;
    A aa3 = func3();//拷贝构造+拷贝构造+优化-》拷贝构造
    cout << "----------------------------" << endl;
    cout << "传值返回用赋值接收" << endl;
    A aa33;
    aa33 = func3();//无优化
    cout << "----------------------------" << endl;
   
    
    
    
    cout << "匿名对象返回" << endl;
    func4();//构造+拷贝构造+优化-》构造
    cout << "----------------------------" << endl;
    A aa4 = func4();//构造+拷贝构造+拷贝构造+优化-》构造
    cout << "----------------------------" << endl;
    return 0;
}

在这里插入图片描述
总结
对象返回
1、接收返回值对象,尽量拷贝构造方式接收,不要赋值接收
2、函数中返回对象时,尽量返回匿名对象
函数传参
1.尽量使用const &传参

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/635463.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

使用自签发CA证书为EMQX开启双向认证

文章目录 背景信息1、CA证书信任模型2、创建证书2.1 Root CA 证书创建2.2 emqx 服务端证书签发2.3 中间CA证书签发2.4 设备证书签发 3、配置EMQX服务端证书4、客户端使用TLS连接EMQX 背景信息 本文主要介绍了通过建立三层CA证书链&#xff0c;为EMQX集群提供PKI服务&#xff0c…

STM32基于库函数新建工程模板

基于库函数版本 准备资料&#xff1a; a) V3.5 固件库包&#xff1a;STM32F10x_StdPeriph_Lib_V3.5.0 这是 ST 官网下载的固件库完 整版&#xff0c;我们光盘目录&#xff1a; 软件资料\STM32 固件库使用参考资料\STM32F10x_StdPeriph_Lib_V3.5.0 我们官方论坛下载地址&#…

C++入门(嵌入式学习)

C入门学习 前言C概述C和C的区别 引用引用概念引用性质引用的应用 C输入和赋值string字符串函数提高函数的默认值默认值的注意事项函数的重载函数重载可能产生的问题扩充 内联函数 前言 C概述 C是一种通用的高级编程语言&#xff0c;它是由Bjarne Stroustrup于20世纪80年代初在…

论文笔记:MEASURING DISENTANGLEMENT: A REVIEW OF METRICS

0 摘要 学习解缠和表示数据中的变化因素是人工智能中的一个重要问题。虽然已经取得了许多关于学习这些表示的进展&#xff0c;但如何量化解缠仍然不清楚。 虽然存在一些度量标准&#xff0c;但对它们的隐含假设、真正衡量的内容以及限制了解甚少。因此&#xff0c;当比较不同的…

睡眠脑电中的神经跨频率耦合函数

导读 人类大脑是一个紧密连接的复杂系统。虽然其结构比较固定&#xff0c;但它可以实现很多不同的功能。其中一个重要的功能是自然睡眠过程&#xff0c;这个过程可以改变意识和随意肌肉活动。在神经层面上&#xff0c;这些改变会伴随着大脑连接的变化。为了揭示这种与睡眠相关…

推荐一个好用的开发工具百宝箱

随着科技不断发展&#xff0c;越来越多的工具在网络上应运而生&#xff0c;方便我们更加高效地完成各种任务。今天我要向大家介绍一款在线工具——码加在线工具 - 做更好的工具&#xff0c;它可以帮助你轻松完成许多繁琐、复杂的工作。 首先&#xff0c;码加在线工具 是一款非…

一维信号进行小波去噪(python)

目录 小波变换小波去噪的原理小波阈值去噪的三个主要方面pywt.threshold函数进行小波去噪对ecg信号进行小波阈值去噪关于阈值输出参考 小波变换 小波变换是一种信号的时间——尺度&#xff08;时间——频率&#xff09;分析方法&#xff0c;它具有多分辨分析的特点&#xff0c…

【模型评估】ROC(Receiver operating characteristic)与 AUC

前面&#xff0c;我们提到了混淆矩阵&#xff0c;以及根据混淆矩阵进一步计算得到的敏感度&#xff08;召回率&#xff09;、特异度、精确度、准确度、F1 Score等等。那他们的前提都是要首先确定一个截断阈值。 【模型评估】混淆矩阵&#xff08;confusion_matrix&#xff09;…

理论粘贴板-背会了避免在大佬面前露馅-常更新

1.OLS说明 最小二乘法。给定序列X(x1,x2…xn),y,估计一个向量A(a0,a1.a2…)令y’a0a1x1a2x2…an*xn, 使得(y’-y)^2最小&#xff0c;计算A。 2.代码如下 来源《python机器学习实践指南》 import patsy import statsmodels.api as sm f ‘Rent ~ Zip Beds’ y, X patsy.dmat…

嘀嗒陪诊完整后台+前端全套小程序代码v1.0.8

就医相关陪护服务升级是未来发展趋势&#xff0c;嘀嗒陪诊是一个可以长期深耕持续运营的项目&#xff0c;并可借此切入拓展衔接养老、护理等领域。 嘀嗒陪诊小程序功能相对简单&#xff0c;后台也简捷&#xff0c;如果只是做个陪诊服务的小程序也基本能满足了&#xff0c;整体…

python基本语法知识(四)——包和模块

模块 例子1&#xff1a;导入某个模块中的具体功能 # 只导入time模块中的sleep方法&#xff0c;可以直接使用sleep调用不用加time. from time import sleep print("hello") sleep(500) print("fine")# 只导入time模块中的sleep方法,并给sleep起别名为sl f…

2023/6/11

BigDecima BigDecima的作用 用于小数的精确计算用来表示很大的小数 创建对象 创建对象时要注意以下细节 BigDecimal的使用和BigInteger类似&#xff0c;唯一要注意的点是&#xff1a;在使用除法时&#xff0c;如果除不尽就要设置精确到几位&#xff0c;否则报错 使用除法时的几…

模拟实现qsort函数(采用冒泡的方式),超详细!!!

函数详解和使用 函数声明 void qsort (void* base, size_t num, size_t size,int (*cmp)(const void* e1,constvoid* e2)); 头文件 stdlib.h 参数 base-- 指向要排序的数组的第一个元素的指针。 num-- 由 base 指向的数组中元素的个数。 size-- 数组中每个元素的大小&a…

高精度电压源的应用场合有哪些

高精度电压源是一种能够提供恒定、稳定电压输出的设备&#xff0c;被广泛应用于各种领域。高精度电压源是现代电力、通信、控制等领域中重要的测试仪器之一&#xff0c;其主要功能是提供稳定可靠的直流或交流电源&#xff0c;并具有高精度和高分辨率的特点。在实际应用中&#…

kotlin 解决构造函数兼容性问题

data class Person(private val head: String,val hand: String ) {} val p Person("head", "hand")Log.d("Alex", "Person $p") 打印结果&#xff1a; 2023-06-11 22:30:54.764 21840-21840 Alex com.example…

智能diy官网小程序至尊版v1.0.73+微信前端

&#x1f388; 限时活动领体验会员&#xff1a;可下载程序网创项目短视频素材 &#x1f388; &#x1f389; 有需要的朋友记得关赞评&#xff0c;文章底部来交流&#xff01;&#xff01;&#xff01; &#x1f389; ✨ 源码介绍 1、h5万*能页增加跳转小程序组件 2、功能链接弹…

智能工具Cursor安装和使用

一、Cursor介绍 Cursor.so是一个软件开发工具&#xff0c;是一个集成了 GPT的直接可以访问的&#xff0c;优秀而强大的智能AI代码生成工具&#xff0c;使用GPT-3.5免费。 它可以快速编写、编辑和聊天关于你的代码。它支持多种编程语言&#xff0c;如Python、Java、JavaScript等…

BootStrap文档

Bootstrap概念 ​ 1. 概念&#xff1a; 一个前端开发的框架&#xff0c;Bootstrap&#xff0c;来自 Twitter&#xff0c;是目前很受欢迎的前端框架。Bootstrap 是基于 HTML、CSS、JavaScript 的&#xff0c;它简洁灵活&#xff0c;使得 Web 开发更加快捷。 ​ 框架:一个半成品…

C++教程(06)——变量类型

C 变量类型 变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有指定的类型&#xff0c;类型决定了变量存储的大小和布局&#xff0c;该范围内的值都可以存储在内存中&#xff0c;运算符可应用于变量上。 变量的名称可以由字母、数字和下划线字符组成。它必须以字母…

037_SS_SyncDiffusion: Coherent Montage via Synchronized Joint Diffusions

SyncDiffusion: Coherent Montage via Synchronized Joint Diffusions 1. Motivations & Arguments & Contributions 本文提出了一种即插即用的用Diffusion生成全景图的方法。 Diffusion模型通常只能生成固定大小的图像&#xff0c;为了生成分辨率比较高的全景图。现…