1. Toy模板网首页
  2. > Toy博客

【C++】类和对象终章

8月前 作者：小羊失眠啦. 分类：Toy博客 阅读(46) 违法举报

这篇具有很好参考价值的文章主要介绍了【C++】类和对象终章。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

【C++】类和对象终章,C++,c++,开发语言
🔥博客主页： 小羊失眠啦.
🎥系列专栏：《C语言》 《数据结构》 《C++》 《Linux》 《Cpolar》
❤️感谢大家点赞👍收藏⭐评论✍️

【C++】类和对象终章,C++,c++,开发语言

本章我们将继续加深对构造函数的学习。认识初始化列表、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;
}

【C++】类和对象终章,C++,c++,开发语言

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;
}

【C++】类和对象终章,C++,c++,开发语言

示例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;
}

【C++】类和对象终章,C++,c++,开发语言

示例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。

【C++】类和对象终章,C++,c++,开发语言

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进行拷贝构造。

【C++】类和对象终章,C++,c++,开发语言

总结起来就是，该语句实现了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;
}

【C++】类和对象终章,C++,c++,开发语言

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;
}

【C++】类和对象终章,C++,c++,开发语言

  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;
}

【C++】类和对象终章,C++,c++,开发语言

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

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

示例

上面我们谈到类型转换。这是典型的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;
}

【C++】类和对象终章,C++,c++,开发语言文章来源地址https://www.toymoban.com/news/detail-841768.html

到了这里，关于【C++】类和对象终章的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【C++】类和对象-封装

    【C++】类和对象-封装

    在main函数前重新补上isSame函数 在Cube类里面添加issamebyclass，利用成员函数判断两个立方体是否相等 自己写的代码： B站视频链接： https://www.bilibili.com/video/BV1et411b73Z/?p=105spm_id_from=333.1007.top_right_bar_window_history.content.clickvd_source=fb8dcae0aee3f1aab700c21099045395

    2024年02月15日
    浏览(47)
  • 【C++】类和对象（3）

    【C++】类和对象（3）

    首先我们先回顾一下构造函数，对象的初始化由构造函数来完成，我们可以在构造函数的函数体内对对象的成员变量进行赋值，但这就有一个问题，如下： 答案：显然不是，因为变量只能定义一次。 也就是说，构造函数的函数体内部并不是初始化的地方（定义的地方），而

    2024年02月06日
    浏览(33)
  • 【C++】类和对象（上）

    【C++】类和对象（上）

    个人主页：平行线也会相交 欢迎 点赞👍 收藏✨ 留言✉ 加关注💓本文由 平行线也会相交 原创 收录于专栏【C++之路】 C语言是面向过程的，而C++是面向对象的，那面向过程和面向对象到底是什么呢？ 我们拿一个非常典型的 外卖系统 来进行举例： 面向过程： 我们知道外面

    2024年02月02日
    浏览(44)
  • 【C++】类和对象(中篇)

    【C++】类和对象(中篇)

    在往期 类和对象(上篇) 中，我们初步接触了C++中的类和对象，接下来我会和大家分享有关这个知识点更多的内容~ 如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成默认成员函数。 默认成员函数：用户

    2024年02月15日
    浏览(57)
  • 【C++】类和对象(四)

    【C++】类和对象(四)

    前言：在类和对象中，我们走过了十分漫长的道路，今天我们将进一步学习类和对象，类和对象这块荆棘地很长，各位一起加油呀。 💖 博主CSDN主页:卫卫卫的个人主页 💞 👉 专栏分类:高质量Ｃ++学习 👈 💯代码仓库:卫卫周大胖的学习日记💫 💪关注博主和博主一起学习

    2024年02月19日
    浏览(33)
  • 【C++】：类和对象（1）

    【C++】：类和对象（1）

    朋友们、伙计们，我们又见面了，本期来给大家解读一下有关C++中类和对象的知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！ C 语 言 专 栏： C语言：从入门到精通 数据结构专栏： 数据结构 个  人  主  页 ： stackY、 目录 1.面向过程和面

    2024年02月08日
    浏览(36)
  • 【C++】类和对象（上篇）

    【C++】类和对象（上篇）

    🚩 C语言 是 面向过程 的， 关注 的是 过程 ，分析出求解问题的步骤，通过函数调用逐步解决问题 🚩 C++ 是基于 面向对象 的， 关注 的是 对象 ，将一件事情拆分成不同的对象，靠对象之间的交互完成 🌰 比如： C语言结构体中只能定义变量， 在C++中，结构体内不仅可以定

    2024年01月22日
    浏览(39)
  • c++类和对象（封装）

    c++类和对象（封装）

            C++面向对象的三大特性为： 封装、继承、多态         C++认为万事万物都皆为对象，对象上有其属性和行为 例如:         人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...车也可以作为对象，属性有轮胎、方向盘、

    2024年02月08日
    浏览(49)
  • C++——类和对象（2）

    C++——类和对象（2）

    当一个类中什么都没有，编译器会帮类自动生成6个默认成员函数例如： 此篇文章主要围绕构造函数与析构函数进行讲解。  对于以上的Date类，每次实例化对象之后都要对对象调用Init()函数，比较繁琐，其实编译器就可以帮我们完成。 构造函数是一个特殊的成员函数，名字与

    2024年03月17日
    浏览(47)
  • C++:类和对象（中）

    C++:类和对象（中）

    如果一个类中什么成员都没有，简称为空类。 空类中真的什么都没有吗？并不是，任何类在什么都不写时， 编译器会自动生成以下6个默认成员函数。 默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数 class Date {}; 对于Date类，可以通过 Init 公有方

    2024年02月03日
    浏览(44)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包