[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。

这篇具有很好参考价值的文章主要介绍了[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

 

目录

1、再谈构造函数

1.1 构造函数体赋值

1.2 初始化列表

1.2.1 初始化列表的意义

1.3 explicit关键字

2、static成员

2.1 问题引入

2.2 特性

3、友元

3.1 友元函数

3.2 友元类

4、内部类


1、再谈构造函数

1.1 构造函数体赋值

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

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

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

我们构造函数尽量给全缺省,这样就算想要实例化一个无参的对象这一个函数就兼顾了。

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

1.2 初始化列表

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

我们继续以Date类来展开看:

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.1 初始化列表的意义

初始化列表是对象的成员变量定义的地方。

有些变量只能在定义的地方初始化:

a. const修饰的变量; b. 引用变量; c. 自定义类型(没有默认构造函数)。

class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a;
};
class Date
{
public:
	// 初始化列表
	Date(int year, int month, int day, int& i)
		: _year(year)
		, _month(month)
		, _day(day)
		, _x(1)
		, _refi(i)
		, _a(1)
	{}

private:
	// 成员变量的声明
	int _year;
	int _month;
	int _day;

	// 定义时必须初始化
	const int _x;
	int& _refi;
	A _a;
};

成员变量给缺省值就是给初始化列表的;初始化列表如果没有显示定义内置类型编译器会给默认定义并给随机值;给缺省并初始化给值使用初始化给的值。

对于定义时必须初始化的成员变量我们看看放在函数体里赋初值的情况:

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

这里就会出错,因此初始化列表对于这样的情况是很适用的。

注意:

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员,必须放在初始化列表位置进行初始化:
a. 引用成员变量
b. const成员变量
c. 自定义类型成员(且该类没有默认构造函数时)
3. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。
4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

初始化后在构造函数体里面还可以再给赋值。

1.3 explicit关键字

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

class Date
{
public:
	Date(int year)
		: _year(year)
	{}

private:
	int _year;
};
int main()
{
	Date d1(2023);

	// 隐式类型转换
	Date d2 = 2023;// 2023调用构造函数生成临时对象,再用临时对象去拷贝构造d2	

	return 0;
}

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

2023是int类型,但是将它赋值给Date类型的d2没有报错,这就是因为2023发生了隐式类型转换。如果我们不想让发生隐士类型转换,给构造函数前加一个explicit修饰。

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

用explicit修饰构造函数,将会禁止构造函数的隐式转换。

引申:

在C++11中,允许多参数的隐式类型转换。

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

private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 隐式类型转换
	Date d = { 2023, 8, 7 };// 多参数隐式类型转换要用{}将多个参数括起来	
	const Date& d1 = { 2023, 1, 1 };// 转换时生成的临时变量具有常性,因此需要const修饰
    
	return 0;
}

多参数隐式类型转换要用 {} 将多个参数括起来。

2、static成员

2.1 问题引入

我们来统计一下A类创建了多少个,正在使用的多少个?

// 创建了多少个对象
int n = 0;
// 正在使用的有多少个对象
int m = 0;
class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}
};
A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << n << " " << m << endl;

	A();// 匿名对象,在本行创建并在本行销毁
	cout << n << " " << m << endl;

	func(a1);
	cout << n << " " << m << endl;

	return 0;
}

运行结果:

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

我们能看到全局变量是可以实现的,但是全局变量是不安全的(全局变量在全局都可以进行修改),并且是不利于封装的,因此我们不用这样的方法。

我们改一下方法来实现:

我们将计数器放在类里面,定义为私有的,但只是这样还是不满足,我们每创建一个对象就会有一个n与m,我们的目的是对象公用,因此我们使用static修饰,这样就解决了这两个问题。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

//private:
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	cout << "sizeof(A):" << sizeof(A) << endl;

	A a1;
	A a2;
	cout << A::n << " " << A::m << endl;

	A();// 匿名对象,在本行创建并在本行销毁
	cout << a1.n << " " << a2.m << endl;

	func(a1);
	cout << a1.n << " " << a2.m << endl;

	return 0;
}

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

这里static修饰之后n与m是静态成员变量就不是某一个对象的了,而是所有对象的,因此不是存在于对象中,而是存在于静态区的(sizeof算出来为1,是一个空类)。

其次,类里只是成员变量的声明,静态成员变量必须在类外定义,定义时就不需要再加static。
如果静态成员我们定义成私有的,需要提供Get接口来访问n,m

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	int GetN()
	{
		return n;
	}
	int GetM()
	{
		return m;
	}

private:
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << a1.GetN() << " " << a1.GetM() << endl;

	A();// 匿名对象,在本行创建并在本行销毁
	cout << a1.GetN() << " " << a1.GetM() << endl;

	func(a1);
	cout << a1.GetN() << " " << a1.GetM() << endl;


	return 0;
}

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

假如我们只创建了两个匿名对象,想要看n、m,没有对象是调用不了的,要是创建一个对象去调用,这就影响了n、m,因此我们将函数也改为静态的,这时只需要加上类域就可以访问了。

class A
{
public:
	A() 
	{ 
		++n;
		++m;
	}
	A(const A & t) 
	{
		++n;
		++m;
	}
	~A() 
	{
		--m;
	}

	// 静态成员函数的特点:没有this指针
	static int GetN()
	{
		return n;
	}
	static int GetM()
	{
		return m;
	}

private:
	// 静态成员变量属于所有A对象,属于整个类
	// 创建了多少个对象
	static int n;
	// 正在使用的有多少个对象
	static int m;
};
int A::n = 0;
int A::m = 0;

A func(A aa)
{
	return aa;
}
int main()
{
	A a1;
	A a2;
	cout << A::GetN() << " " << A::GetM() << endl;

	A();// 匿名对象,在本行创建并在本行销毁
	cout << A::GetN() << " " << A::GetM() << endl;

	func(a1);
	cout << A::GetN() << " " << A::GetM() << endl;

	return 0;
}

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

注意:静态成员函数里不能访问非静态成员函数,因为没有this指针。一般static修饰的成员变量于static修饰的成员函数是配套使用的。

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

2.2 特性

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

3、友元

友元分为友元函数友元类。

友元提供了一种突破封装的方式,有时提供了便利。但是友元破坏了封装,所以友元不宜多用。

3.1 友元函数

问题:上一篇中我们实现了Date类的所有需要重载的运算符,如果我们需要使用cout来打印自定义类型对象,我们需要对流插入符号进行重载。

打印的格式为cout << " " << endl;

那么重载流插入符号就不可以在类里面,在类里第一个参数是隐含的this指针,会与cout抢第一个参数位置,因此我们只能定义在类外面。
放在外面我们就无法访问类成员变量了,这里就该我们的友元上场了。

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

class Date
{
	// 友元
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

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

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

ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

int main()
{
	Date d1;
	cin >> d1;
	cout << d1;
}

运行结果:

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

说明:

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

3.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

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
{
	// 友元
	friend ostream& operator<<(ostream& out, const Date& d);
	friend istream& operator>>(istream& in, Date& d);

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;

};
ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << " " << d._month << " " << d._day;
	return out;
}
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}

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

4、内部类

概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。就是在一个类里面再定义一个类内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

class A
{
public:
	class B
	{

	private:
		int _b;
	};
	int _a;
};
int main()
{
	cout << sizeof(A) << endl;
}

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

这里打印出来是4,因此我们可以知道,sizeof(外部类) = 外部类的大小,虽然里面嵌套了内部类,但内部类是不算在外部类大小里面的。

其次,内部类默认是外部类的友元类。

class A
{
public:
	class B
	{
	public:
		void func()
		{
			A a;
			a._a = 1;
			cout << a._a << endl;
		}

	private:
		int _b;
	};

private:
	int _a;
};
int main()
{
	A::B b;
	b.func();

	return 0;
}

我们在B类中定义了一个函数,函数里面访问A类的成员变量_a,并且给其赋值了,来看是否可以正常运行。

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

我们这里可以看到,在B类中可以访问到A类的成员变量,并且为其赋值了。这就可以看出来B类是A类的友元。

但是,A类不是B类的友元,友元是单向的。

[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。,C++,c++,开发语言

特性:

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员,不需要外部类的对象/类名。
3. sizeof(外部类)=外部类,和内部类没有任何关系。文章来源地址https://www.toymoban.com/news/detail-650898.html

到了这里,关于[C++]类与对象(下) -- 初始化列表 -- static成员 -- 友元 -- 内部类,一篇带你深度了解。的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++入门到精通】C++入门 —— 类和对象(初始化列表、Static成员、友元、内部类、匿名对象)

    目录 一、初始化列表 ⭕初始化列表概念 ⭕初始化列表的优点 ⭕使用场景 ⭕explicit 二、Static成员 ⭕Static成员概念 🔴静态数据成员: 🔴静态函数成员: ⭕使用静态成员的优点 ⭕使用静态成员的注意事项 三、友元 ⭕友元的概念 ⭕类友元 ⭕函数友元  四、内部类 ⭕

    2024年02月14日
    浏览(45)
  • 【C++练级之路】【Lv.4】类和对象(下)(初始化列表,友元,static成员,编译器的优化)

    欢迎各位小伙伴关注我的专栏,和我一起系统学习C++,共同探讨和进步哦! 学习专栏 : 《进击的C++》 在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象

    2024年02月04日
    浏览(56)
  • C++:初始化列表,static成员,友元,内部类

    个人主页 : 个人主页 个人专栏 : 《数据结构》 《C语言》《C++》 本篇博客作为C++:初始化列表,static成员,友元,内部类的知识总结。 初始化列表:以冒号开始,接着是一个以逗号分隔的数据成员列表,每个“成员变量”后面跟一个放在括号中的初始值或表达式。 初始化

    2024年02月07日
    浏览(55)
  • 4.【CPP】入门(初始化列表||explicit||static||友元||静态成员变量/函数)

    我们知道在c++11中才能在成员对象声明时初始化,像下面这样。 注意:构造函数不是初始化,而是赋初始值。那么在c++11以前该怎么初始化成员变量呢? 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次) 类中包含以下成员,必须放在初始化列表位置进行初始

    2024年01月20日
    浏览(42)
  • 【C++基础】类与对象(下) 初始化列表、友元、内部类、匿名对象

    ​👻内容专栏: C/C++编程 🐨本文概括: C++基础语法。初始化列表、 explicit 、 static 成员、友元、内部类、匿名对象、拷贝对象时的一些编译器优化等。 🐼本文作者: 阿四啊 🐸发布时间:2023.9.8 在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个

    2024年02月09日
    浏览(49)
  • c++类和对象(拷贝构造、运算符重载、初始化列表、静态成员、友元等)

    拷贝构造函数的特征: 1、拷贝构造函数是构造函数的一个重载形式; 2、拷贝构造函数的参数只有一个且必须是同类类型对象的引用, 使用传值方式编译器直接报错 ,因为会引发无穷递归调用。 在c++中自定义类型 传值传参 的时候要调用拷贝构造函数。 3、若未显式定义,

    2024年02月15日
    浏览(36)
  • 【C++技能树】类和对象的使用 --初始化列表,static,友元,内部类,匿名对象的理解与使用

    Halo,这里是Ppeua。平时主要更新C语言,C++,数据结构算法…感兴趣就关注我bua! 这是一个C++的默认构造函数 虽然我们大多时候混淆初始化与赋值的概念,但在这里,构造函数体中只能成为 赋值 ,因为初始化只能初始化一次,而赋值可以赋值多次。 那么在哪里进行初始化呢

    2024年02月06日
    浏览(44)
  • C++——初始化列表 | explicit关键字 | static成员

    🌸作者简介: 花想云 ,在读本科生一枚,致力于 C/C++、Linux 学习。 🌸 本文收录于 C++系列 ,本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等,专为大学生打造全套 C++ 学习教程,持续更新! 🌸 相关专栏推荐: C语言初阶系列 、 C语言进阶系列 、 数据结构与算法 本章我们

    2023年04月11日
    浏览(49)
  • 【C++基础(六)】类和对象(下)--初始化列表,友元,匿名对象

    💓博主CSDN主页:杭电码农-NEO💓   ⏩专栏分类:C++初阶之路⏪   🚚代码仓库:NEO的学习日记🚚   🌹关注我🫵带你学习C++   🔝🔝 关于类和对象的大致内容已经结束 本篇文章主要是介绍一些冗杂的细节 虽然本节的内容属于对类和对象锦上添花 但在很多特定的场所下,还是

    2024年02月14日
    浏览(62)
  • 【C++干货基地】面向对象核心概念 const成员函数 | 初始化列表 | explicit关键字 | 取地址重载

    🎬 鸽芷咕 :个人主页  🔥 个人专栏 : 《C++干货基地》《粉丝福利》 ⛺️生活的理想,就是为了理想的生活!   哈喽各位铁汁们好啊,我是博主鸽芷咕《C++干货基地》是由我的襄阳家乡零食基地有感而发,不知道各位的城市有没有这种实惠又全面的零食基地呢?C++ 本身作

    2024年04月23日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包