＜C++＞类和对象——补充

最新推荐文章于 2024-05-20 19:43:04 发布
最新推荐文章于 2024-05-20 19:43:04 发布
阅读量116 收藏
点赞数 2
分类专栏： C++ 自学教程 文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47882731/article/details/125772211
版权

文章目录

1. 再谈构造函数

1.1 初始化列表

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

初始化列表可以认为成是对象成员变量定义的地方

class Date
{
public:
	//函数体内初始化
	//Date(int year = 1, int month = 1, int day = 1)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
    
	//初始化列表
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		,_month(month)
		//,_day(day)
	{
		_day = day;//可以分开来初始化
	}
private:
	int _year; //声明
	int _month;
	int _day;
};

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

  • 引用成员变量

  • const成员变量

  • 自定义类型成员(该类没有默认构造函数)

int value = 10;
class Date
{
public:
	//初始化列表可以认为成是对象成员变量定义的地方
	Date(int year, int n, int a)
		:_n(n)
		, _ref(value)//const和引用一定要在初始化列表里初始化
	{
		_year = year;
	}
private:
	//定义时初始化
	//也可以定义时不初始化，后面赋值的时候再改
	int _year; //声明

	//只能在定义时初始化
	const int _n;
	int& _ref;
};

初始化自定义类型成员的办法

class A
{
public:
	A(int x) //方法1：写默认构造函数A(int x = 10)
		:_x(x)
	{}
private:
	int _x;
};

class Date
{
public:
	//初始化列表可以认为成是对象成员变量定义的地方
	Date(int a)
		: _aa(a) //方法2：初始化列表
	{
		//A aa(a); //方法3：在A有默认构造函数的基础上嵌套，用a初始化aa，把aa赋值给_aa
		//_aa = aa;
	}
private:
	A _aa;
};

其他的变量既可以在初始化列表初始化，也可以在函数体内初始化

建议尽量全都在初始化列表初始化

class Stack
{
public:
	Stack(int capacity = 0)
	{
		_a = (int*)malloc(sizeof(int) * capacity);
		assert(_a);
		_top = 0;
		_capacity = capacity;
	}
private:
	int* _a;
	int _top;
	int _capacity;
};

class MyQueue
{
public:
	MyQueue(int size = 1)
		:_size(size) // 这样写缺省值就没用了，最后_size的值是1
	{}

private:
	Stack _st1;
	Stack _st2;
	size_t _size = 10; // 缺省值
};

编译器默认生成的构造函数和自己写的无参的构造函数效果一样

因为初始化列表里面显式初始化了一个成员，它就会初始化，如果你没有写，它也会初始化（自定义类型调用默认构造，内置类型赋随机值）

缺省值本质上是给初始化列表用的，但有显式初始化时，缺省值就没用了。

  1. 相当于每个成员都会走一遍初始化列表，如果列表里有显式初始化，就按着来；如果列表里没写，自定义类型成员就调用它的默认构造，内置类型成员看它有没有缺省值，没有的话就赋随机值

  2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

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();
	return 0;
}

A.输出1 1

B.程序崩溃

C.编译不通过

D.输出1 随机值

正确选项：D（先初始化_a2，用_a1初始化_a2，那时_a1还是随机值。之后才用a的值1初始化_a1）

1.2 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

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

	/*explicit Date(int year)//有了explicit就不支持隐式类型转换了
		:_year(year)
	{}*/
private:
	int _year;
	int _month;
	int _day;
};

void Func(const string& s)
{}

int main()
{
	Date d1(2018);

	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2019构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2019;//相当于Date d2(2019);d1 = d2;

	//这个用法在string类里面比较实用
	string s1("hello");
	string s2 = "hello";
	Func(s1);
	Func("hello");

	return 0;
}

上述代码可读性不是很好，用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

2. static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。

静态的成员变量一定要在类外进行初始化

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

//统计A类型对象创建了多少个
//可以用全局变量，但不推荐（别人能随便改，推荐封装起来）。在这我们引入静态成员变量的概念
//int count1 = 0;
//int count2 = 0;
class A
{
public:
	A()// 构造
	{
		++_count1;
	}
	A(const A& aa)// 拷贝构造
	{
		++_count2;
	}

	// 静态成员函数，没有this指针
	static int GetCount1()
	{
		//_a = 1;//静态成员变量里不能访问非静态成员，因为没有this指针
		return _count1;
	}
	static int GetCount2()
	{
		return _count2;
	}

private:
	// 静态成员变量属于整个类，属于类的所有对象
	static int _count1;// 声明
	static int _count2;

	int _a;
};

int A::_count1 = 0;// 定义
int A::_count2 = 0;

A Func(A a)
{
	A copy(a);
	return copy;
}

int main()
{
	A a1;
	A a2 = Func(a1);
	// 静态成员变量属于整个类，属于类的所有对象
	
	 如果静态成员变量是公有的
	 可以通过对象访问
	//cout << a1._count1 << endl;
	//cout << a1._count2 << endl;
	//cout << a2._count1 << endl;
	//cout << a2._count2 << endl;
	 可以指定类域访问
	//cout << A::_count1 << endl;
	//cout << A::_count2 << endl;

	// 如果静态成员变量是私有的
	// 我们写函数来传递
	// 静态成员函数，没有this指针，这里的a1.不是为了传递this指针，而是为了指定类域
	cout << a1.GetCount1() << endl;
	cout << a2.GetCount2() << endl;
	// 也可以直接指定类域
	cout << A::GetCount1() << endl;
	cout << A::GetCount2() << endl;

	return 0;
}

【特性】

  1. 静态成员为所有类对象所共享，不属于某个具体的实例
  2. 静态成员变量必须在类外定义，定义时不添加static关键字
  3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

3. C++11 的成员初始化新方式

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值 

class B
{
public:
	B(int b = 0)
		:_b(b)
	{}
	int _b;
};
class A
{
public:
	void Print()
	{
		cout << a << endl;
		cout << b._b << endl;
		cout << p << endl;
	}
private:
	// 非静态成员变量，可以在成员声明时给缺省值。
	int a = 10;
	B b = 20;
	int* p = (int*)malloc(4);
	// 静态成员变量，要在定义时给初始值，否则会只有声明没有定义。（非静态成员变量在初始化列表定义，它们声明时给缺省值就够用了）
	static int n;
};
int A::n = 10;
int main()
{
	A a;
	a.Print();
	return 0;
}

4. 友元

友元分为：友元函数和友元类

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

4.1 友元函数

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

这里举的例子是上一篇文章末尾的<< 和>>函数重载写法 类的六个默认成员函数

class Date
{
	//友元函数（允许类外的函数访问私有的成员变量）
	friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::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;
};

std::ostream& operator<<(std::ostream& out, const Date& d)//out是cout对象的别名
{
	out << d._year << "-" << d._month << "-" << d._day << endl;//成员变量是私有的，用友元函数
	return out;//支持连续提取
}

std::istream& operator>>(std::istream& in, Date& d)//in是cin对象的别名
{
	in >> d._year >> d._month >> d._day;//成员变量是私有的，用友元函数
	//这里最好再判断一下日期的合法性
	return in;//支持连续提取
}

说明：

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

4.2 友元类

class Date; // 前置声明（编译器向上找，这里是告诉编译器Date是个类）
class Time
{
	friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 1, int minute = 1, int second = 1)
		: _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;
};

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

友元关系是单向的，不具有交换性。

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递

如果B是A的友元，C是B的友元，则不能说明C时A的友元。

5. 内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。

注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系
class A
{
private:
	static int k;
	int h;
public:
	// 内部类
	class B// B类天生就是A类的友元（A不是B的友元）
	{
	public:
		void foo(const A& a)
		{
			cout << k << endl;//OK
			cout << a.h << endl;//OK
		}
	private:
		int _b;
	};
	//A不是B的友元
	//void Print(const B& b)
	//{
	//	b._b = 0;//不行
	//}
};
int A::k = 1;
天影云光
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++整理笔记word版 ——02 C++核心编程
12-06
C++整理笔记word版 本阶段主要针对C++面向对象编程技术做详细讲解，探讨C++中的核心和精髓。是01 C++学习笔记的后续补充 内存分区模型 引用 函数提高 类和对象 文件操作
类中static成员初始化
csdn_walter的博客
09-21 1301
类中static成员初始化
初始化列表、static成员、友元
qq_51210661的博客
05-19 92
文章目录再谈构造初始化列表 再谈构造 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 class Date { public: Date(int year=2021, int month=5, int day=18) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不
java：给定一个时日期，加上天数之后，输出加上天数后的日期。
iilegend的博客
05-18 3869
    public static void main(String[] args) throws ParseException { plusDay(18,"2018-05-18"); } /** * 指定日期加上天数后的日期 * @param num 为增加的天数 * @param newDate 创建时间 * @return * @t...
成员初始化列表顺序
雪儿的专栏
07-28 468
常量必须在构造函数初始化列表里面初始化，或者将其设置为static. class A{ A() {      const int size=7; } }; 或者 class A{ stattic const int Size=9;   //去掉static后是错误的。 }；
【C++】类和对象——构造函数
Ye_Ming_OUC的博客
08-16 1650
文章摘要：什么是构造函数、默认构造函数、初始化列表、通过构造函数进行隐式类型转换的条件、C++11变量初始化新玩法
C++ 库函数＜string＞示例
qq_57273600的博客
07-27 721
关于一些C++的字符串处理函数详解，经验分享。
C++:类和对象——“类的详细介绍”，“this指针”
zhang_si_hang的博客
05-13 710
1.面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 拿外卖来举例子，C语言面向过程看的是：点外卖，送外卖，拿外卖。C++面向对象看的是：商家，骑手，用户。 2.类的引入 （1）C语言中，结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。 C++兼容C struct的用法 C++同时对struct......
植物大战 类和对象 ——C++
热门推荐
一些七零八碎的知识点
08-03 1万+
C++ 类和对象
【 C++ 】类和对象（中）—— 类的6个默认成员函数
bit_zyx的博客
06-04 3233
目录 1、类的6个默认成员函数 2、构造函数 构造函数概念 构造函数特性 3、析构函数 析构函数概念 析构函数特性 4、拷贝构造函数 拷贝构造函数概念 拷贝构造函数特性 5、赋值运算符重载 运算符重载 赋值运算符重载 6、const成员 const修饰类的成员函数 7、取地址及const取地址操作符重载 1、类的6个默认成员函数 ......
简要介绍C++编程中的友元函数和友元类
01-20
一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。现在，我们来补充介绍一个例外——友元（friend）。 fnend 的意思是朋友...
c++11智能指针解析——揭开底层面纱，完整理解智能指针.pdf
02-27
c++11智能指针解析——揭开底层⾯纱，完整理解智能指针 昨天跟同事⼩⼩的研究了下关于不同平台下的字节对齐问题，起因是遇到了⼀个坑，vs上没有问题，在安卓上却崩溃了。找了半天后发现是 c++字节补齐问题，期间包括...
C++复习补充
04-21
C++复习补充 一、指针 a.指针的基本概念 指针——存储数据对象的存储地址。图（1）中存储单元FF01、FF03、FF08、FF0A都存储数据对象的存储地址。例如FF01中存储地址FF02，FF02中存储的是英文字符“b”，称FF02是...
json对象转字符串如何实现
12-08
背景：大部分浏览器已经实现了json对象转字符串的原生api支持，那在较低版本浏览器浏览器——如大家最喜爱的IE6——里如何实现呢？ 首先运行以下方法，测试各种情况下，JSON.stringify的输出，这有助于下文代码的...
c语言中int year,大神来帮帮我int countDays(int year,i
weixin_33054119的博客
05-19 490
该楼层疑似违规已被系统折叠隐藏此楼查看此楼大神来帮帮我int countDays(int year,int month,int day){int sum;switch(month){case 1: sum=0;break;case 2: sum=31;break;case 3: sum=59;break;case 4: sum=90;break;case 5: sum=120;break;cas...
c语言操作注意事项
最新发布
dropLin的博客
05-20 114
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 898
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
【C语言深度解剖】(14)：结构体内存对齐（详细配图讲解）
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-20 412
一篇文章带你学会结构体的内存对齐！！超多精美配图！
<iostream> 和<fstream>
10-29
<iostream>和<fstream>都是C++中的头文件，用于输入和输出。其中，<iostream>主要用于控制台输入输出，而<fstream>主要用于文件输入输出。 引用[1]中提到了<iostream>和<sstream>，但并未详细解释它们的作用。实际...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天影云光

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值