1. AI技术聚合首页
  2. IT

【C++】类和对象终章

心中带点小风骚 • • IT • 阅读 27


🔥博客主页： 小羊失眠啦.
🎥系列专栏：《C语言》 《数据结构》 《C++》 《Linux》 《Cpolar》
❤️感谢大家点赞👍收藏⭐评论✍️

文章目录

  • 一、初始化列表
    • 1.1 初始化列表的形式
    • 1.2 初始化列表的注意事项
  • 二、explicit关键字
    • 2.1 单参数构造函数
    • 2.2 多参数构造函数
  • 三、static成员
    • 3.1 static成员的概念
    • 3.2 static成员的特性
  • 四、友元
    • 4.1 概念
    • 4.2 友元函数
    • 4.3 友元类
  • 五、内部类（不常用）
    • 5.1 内部类的性质
  • 六、匿名对象
  • 七、关于拷贝对象时一些编译器优化

本章我们将继续加深对构造函数的学习。认识初始化列表、explicit关键字、static成员、学习static成员的相关特性、学习友元的概念，包含友元函数和友元类；内部类；匿名对象以及关于拷贝构造时一些编译器优化的情况等。

一、初始化列表

在构造函数的学习中，我们知道可以通过构造函数对一个对象的成员变量赋初始值。我们以Date类为例：

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

		void print()
		{
			cout << _year << "年" << _month << "月" << _day << "日" << endl;
		}
	private:
		int _year;
		int _month;
		int _day;
	};

	
}

int main()
{
	Aron::Date d1(2024, 3, 16);
	d1.print();
	return 0;
}

虽然上述过程中通过构造函数的调用使得对象d1确实有了一个初始值，但是我们并不能将该过程称为对对象中成员变量的初始化。

  • 构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

那么初始化在何时进行呢？这就要提一提本章的主角之一初始化列表了。

1.1 初始化列表的形式

初始化列表：

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

示例：

namespace Aron
{
	class Date
	{
	public:
		Date(int year, int month, int day)
			:_year(year)
			,_month(month)
			,_day(day)
		{
			/*_year = year;
			_month = month;
			_day = day;*/
		}

		void print()
		{
			cout << _year << "年" << _month << "月" << _day << "日" << endl;
		}
	private:
		int _year;
		int _month;
		int _day;
	};

	
}

int main()
{
	Aron::Date d1(2024, 3, 16);
	d1.print();
	return 0;
}

1.2 初始化列表的注意事项

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

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

    • 引用成员变量；

    • const成员变量；

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

namespace Aron
{
	class A
	{
	public:
		A(int a)
			:_a(a)
		{}
	private:
		int _a;
	};

	class B
	{
	public:
		B(int a,int i,int b)
			:_b(a)
			,_i(i)
			,_a(b)
		{}
	private:
		int& _b;
		const int _i;
		A _a;
	};
}
  1. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

注意事项

有的小伙伴会误认为给成员变量赋缺省值就是初始化，切记只有在初始化列表中才进行初始化。

namespace Aron
{
	class Date
	{
	public:
		void print()
		{
			cout << _year << "年" << _month << "月" << _day << "日" << endl;
		}
	private:
		int _year = 0;
		int _month = 0;
		int _day = 0;
	};
}
  1. 成员变量在类中声明顺序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

示例1：

namespace Aron
{
	class C
	{
	public:
		C()
			:a(10)
			,b(a)
		{}

		void print()
		{
			cout << "a=" << a << endl;
			cout << "b=" << b << endl;
		}
	private:
		int a;
		int b;
	};
}

int main()
{
	Aron::C c;
	c.print();
	return 0;
}

示例2：

namespace Aron
{
	class D
	{
	public:
		D()
			:b(10)
			, a(b)
		{}

		void print()
		{
			cout << "a=" << a << endl;
			cout << "b=" << b << endl;
		}
	private:
		int a;
		int b;
	};
}

int main()
{
	Aron::D d;
	d.print();
	return 0;
}

示例2中，出现该结果的原因是成员变量的声明顺序为先a后b，则初始化顺序也应该为先a后b。a在初始化时，使用b的值，而此时b还未初始化b的值为随机值，所以a的值也为随机值。接下来用10初始化b，所以b的值为10。

二、explicit关键字

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

什么是类型转换？

int a = 100;
double b = a;

如上所示，a并不是直接赋值给b，而是先进行了隐式类型转换：

  1. 创建一个double类型的临时变量；
  2. 将a的值赋予临时变量；
  3. 将临时变量的值赋予b。

2.1 单参数构造函数

举例

定义一个Date类，且该类的构造函数只有一个参数，我们称为单参数构造函数：

namespace Aron
{
    class Date
    {
        public:
        Date(int year)
            :_year(year)
            {}
        private:
        int _year=0;
    };
}

Aron::Date d1(2024);

这是我们常见的创建一个对象的写法，此外还可以这样写：

Aron::Date d2 = 2024;

注意事项

  • 此处这种写法是我们的赋值运算符重载吗？
    答案是，当然不是。赋值重载实现的功能是用一个已存在的对象赋值给另外一个已存在的对象。

那么为什么100可以赋值给d1呢？这是由于类型转换的原因。具体实现过程如下：

  1. 用100构造一个Date类型的临时对象；

  2. 再用临时对象对d1进行拷贝构造。

总结起来就是，该语句实现了2个过程——1个构造+1个拷贝构造。

如何证明这一过程呢？

这就要用到explicit关键字了。

  • explicit修饰的构造函数禁止类型转换。

示例

namespace Aron
{
	class Date
	{
	public:
		explicit Date(int year)
			:_year(year)
		{}
	private:
		int _year = 0;
		int _month = 0;
		int _day = 0;
	};

}

int main()
{
	Aron::Date d = 100;
	return 0;
}

2.2 多参数构造函数

多参数构造函数与单参数类似。C++98中只支持除第一个参数外，其余参数都有默认值的情况。C++11中引进了一种新的写法。

示例1(C++98)

namespace Aron
{
    class Date
    {
    public:
        //除第一个参数外，其余都有默认值
        //加上explicit关键字会报错
        Date(int year, int month=0, int day=0)
            :_year(year),
            _month(month),
            _day(day)
        {}
    private:
        int _year;
        int _month;
        int _day;
    };
}

int main()
{
	Aron::Date d2 = 100;
	return 0;
}

示例2(C++11)

namespace Aron
{
    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()
{
	Aron::Date d2 ={2024,3,16};//使用大括号
	return 0;
}

三、static成员

3.1 static成员的概念

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

namespace Aron
{
    class A
    {
    public:
        int getN()
        {
            return n;
        }
    private:
        //类中进行声明
        static int n;
    };
    
    //类外进行定义与初始化
	int A::n = 0;
}

3.2 static成员的特性

  1. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明；
  2. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问；
  3. 静态成员也是类的成员，受public、protected、private 访问限定符的限制；

示例1

namespace Aron
{
	class A
	{
	public:
		int getN()
		{
			return n;
		}

		static int m;
	private:
		//类中进行声明
		static int n;
	};

	//类外进行定义与初始化
	int A::n = 0;
	int A::m = 0;
}

int main()
{
	Aron::A a;
	a.m += 10;
	cout << a.getN() << endl;
	cout << a.m << endl;
	return 0;
}

  1. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员；

示例2

namespace Aron::
{
	class B
    {
    public:
        static int getN()
        {
            //错误示例
            //静态函数不能直接访问非静态成员
            //_a++;

            return n;//可以访问静态成员
        }
    private:
        static int n;
        int _a;
    };
}
  1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。

题目链接：求1+2+3+…+n。

这道题可以很好的帮我们理解第5条性质。

解题思路

利用static成员被类的所有对象所共用的特性。声明static成员变量n，每创建一个对象就++n。再声明一个static成员变量sum，求所有n的和。

class sum
{
public:
	sum()
	{
		_sum += _i;
		_i++;
	}
	static int GetSum()
	{
		return _sum;
	}

private:
	static int _sum;
	static int _i;
};
int sum::_sum = 0;
int sum::_i = 1;

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

四、友元

面向对象有三大特性——封装、继承、多态。从学习C++至今，我们一直在谈封装的重要性。但是在某些特殊的情况下，有时需要突破封装的限制。

举例

之前我们通过实现日期类来学习运算符重载。其中实现操作符<<（流插入）、>>（流提取）的重载时，我们遇到了难题——如果在类中实现<<>>重载，我们无法调换this指针的位置，导致实现出来的重载<<用起来怪怪的。如下：

namespace Aron
{
	class Date
    {
    //...
        //使用因为返回，为了适应连续输入或输出的情况
        ostream& operator<<(ostream& out)
        {
            out << _year << "年" << _month << "月" << _day << "日" << endl;
            return out;
        }
        istream& operator>>(istream& in)
        {
            in >>_year >>_month >>_day;
            return in;
        }
        //...
    }
}
void Test()
{
	Aron::Date d1(2024, 3, 16);
	d1 << cout;//有点奇怪
}

还记得当时我们是怎么解决的吗？答案是，可以将两个函数改为友元函数。例如：

namespace Aron
{
	class Date
    {
    //...
        //声明友元函数
        friend ostream& operator<<(ostream& out, const Date& d);
        friend istream& operator>>(istream& in, Date& d);
        //...
    };
    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;
	}
}

上次我们只是浅浅的看了一下友元函数的使用。今天我们正式认识一下友元。

4.1 概念

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

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

4.2 友元函数

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

友元函数的重要性质

友元函数有如下几条重要的性质：

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

4.3 友元类

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

namespace Aron
{
    class Time
    {
        friend class Date;//声明日期类为时间类的友元类，则在日期类中可以直接发访问时间类
        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 = 2023, int month = 4, int day = 9)
            : _year(year)
            , _month(month)
            , _day(day)
        {}
        void SetTime(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类中私有的成员变量则不行。

  • 友元关系不能传递；

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

  • 友元关系不能继承（先不做解释）；

五、内部类（不常用）

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

内部类有一个重要的性质——内部类天生就是外部类的友元。参照友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

5.1 内部类的性质

  1. 内部类可以定义在外部类的public、protected、private下。
  2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象或类名。
  3. sizeof(外部类)=外部类，说明外部类和内部类在空间上没有任何关系。

六、匿名对象

匿名对象，顾名思义，该对象没有名字就叫匿名对象。匿名对象重要的性质：

  • 匿名对象的生命周期只在定义它的那一行；

示例

namespace Aron
{
    class A
    {
    public:
        class B // B天生就是A的友元
        {
        public:
            void print(const A& a)
            {
                cout << k << endl;
                cout << a.n << endl;
            }
        };
    private:
        //声明static成员
        static int k;
        int n = 0;
    };

    //初始化static成员
    int A::k = 1;
}

int main()
{
	Aron::A::B b;//定义B类对象

	Aron::A a;
	b.print(a);
	return 0;
}

匿名对象看似鸡肋，但在某些场合下非常适用。比如，我们只想拿到类内部的某个成员的值，或只是想用一下类中的某个成员函数，为了一件简单的事而专门定义一个对象再销毁显得有点多此一举，那么就可以使用匿名对象。

namespace Aron
{
	class solution
	{
	public:
		int Sum_Solution(int n)
		{
			int sum = 0;
			for (int i = 1; i <= n; i++)
			{
				sum += i;
			}
			return sum;
		}
	};
}

int main()
{
	//匿名对象的使用场景
	cout << Aron::solution().Sum_Solution(100) << endl;
	return 0;
}

七、关于拷贝对象时一些编译器优化

对于有些场景下，若出现拷贝构造与构造同时出现的情况，编译器可能省略中间的拷贝构造，转化为直接构造。（此种情况取决于不同编译器不同的实现方法）

示例

上面我们谈到类型转换。这是典型的1个拷贝构造+1个构造优化为——>直接构造。

namespace Aron
{
	class Date
    {
    public:
        Date(int year)
            :_year(year)
        {}
    private:
        int _year=0;
    };
}

void Test()
{
	//1个拷贝构造+1个构造优化为——>直接构造
	Aron::Date d = 2024;
}

其它情况

class A
{
public:
	A(int a = 0)
		:_a(a)
	{}
private:
	int _a;
};


void func1(A aa)
{

}

void func2(const A& aa)
{

}

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

A func4()
{
	return A();
}

int main()
{
	A aa1 = 1; // 构造+拷贝构造 ——> 优化为直接构造
	func1(aa1); // 无优化
	func1(2); // 构造+拷贝构造 ——> 优化为直接构造
	func1(A(3)); // 构造+拷贝构造——> 优化为直接构造
	func2(aa1);  // 无优化
	func2(A(3)); // 无优化

	A aa2 = func3(); // 拷贝构造+拷贝构造  -- 优化为一个拷贝构造

	A aa3;
	aa3 = func3();  // 不能优化

	func4(); // 构造+拷贝构造 -- 优化为直接构造
	A aa4 = func4(); // 构造+拷贝构造+拷贝构造  -- 优化为直接构造

	return 0;
}

版权声明：本文为博主作者：小羊失眠啦.原创文章，版权归属原作者，如果侵权，请联系我们删除！

原文链接：https://blog.csdn.net/hsjsiwkwm/article/details/136764937

共计人评分，平均分

到目前为止还没有投票！成为第一位评论此文章。

赞 (0)
心中带点小风骚的头像心中带点小风骚普通用户
0
上一篇 2024年4月10日
下一篇 2024年4月10日

相关推荐