类与对象（下）

Victoria.a2025-01-29 9:11

再谈构造函数

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

cpp 复制代码 
class Date
{
public:
Date(int year, int month, int day)
 {
     _year = year;
     _month = month;
     _day = day;
 }
private:
int _year;
int _month;
int _day;
};

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

变量定义是在初始化列表，没显示写初始化列表默认是随机值，但是也会走初始化列表

初始化列表

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

cpp 复制代码 
class A
{
public:
    A(int a)
        :_a(a)
    {
        cout << "A(int a = 0)" << endl;
    }
private:
    int _a;
};

namespace jzy
{
    class Date
    {
    public:


        Date(int year, int month, int day)
           :_year(2)
           ,_ref(year)
           ,_n(1)
           //,_aa(10)
        {
            // 剩下3个成员没有在初始化列表显示写出来定义
            // 但是他也会定义，只是内置类型默认给的随机值
            // 如果是自定义类型成员会去调用它的默认构造函数
            
            // 函数体内初始化
            _year = year;
            _month = month;
            _day = day;
        }

    private:
        // 声明
        int _year = 1; // 缺省值
        int _month = 1;
        int _day;

        A _aa=100;        // 定义类型成员(且该类没有默认构造函数时)

        int& _ref;	  // 引用 ： 必须在定义的时候初始化
        const int _n; // const ： 必须在定义的时候初始化
    };
}


int main()
{

    jzy::Date d1(2025, 10, 31);
    return 0;
}

初始化列表没有显示给也会定义，内置类型不做处理，自定义类型会调用它的默认构造（默认缺省值给0，没有缺省值的话会报错-》没有合适的构造函数可以用）

记住，c++规定某些类型比如const和引用必须在定义的时候初始化，初始化列表就是定义的地方，Date d1是定义对象的地方，初始化列表是定义每个成员的地方，因为定义意味着开空间，开了空间才能使用它们

能用初始化列表就用初始化列表，函数体内是赋值，如果初始化列表没有定义还得再次给值，还不如直接在初始化列表定义的时候初始化

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

cpp 复制代码 
using namespace std;
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();
}

A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值

选D

所以要注意初始化的顺序和声明顺序一致

explicit****关键字

cpp 复制代码 
class A
{
public:
	//explicit A(int a) 
	A(int a)
		:_a(a)
	{}

	int _a = 0;
};


int main()
{
	A aa1(1);
	A aa2(2);

	 //内置类型对象 隐式转换成自定义类型对象
	 //能支持这个转换，是有A的int单参数构造函数(支持传一个参数多参数带缺省也可以)支持
	 //不想让隐式类型转换发生，构造函数加explicit
	A aa3 = 3;
	const A& ra = 3;//引用会引用临时对象，临时对象有常属性，防止权限扩大要加上const
	//引用的是拷贝构造生成的对象  并且延长这块拷贝的临时对象的生命周期

	int* p = NULL;
	A aa4 = p;

	// 内置类型  整形和浮点 隐式互相转
	//int i = 0;
	//double d = i;
	//const double& r = i;



	return 0;
}

这里隐式类型转换只能是构造函数是单参数，并且是相同类型的才能这样写。用explicit修饰构造函数，将会禁止构造函数的隐式转换。

cpp 复制代码 
#include<iostream>
using namespace std;
#include<list>
class A
{
public:
	 A(int a) 
		:_a(a)
	{}
	 ~A()
	 {
		 cout << this << endl;
	 }

	int _a = 0;
};

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;
};
int main()
{
	Date d1(2025, 11, 2);
	Date d2 = (2025, 11, 3); // 等价于 Date d2 = 3;
	Date d3 = 2025;

	 //C++11
	Date d4 = { 2025, 11, 2 };//多参数也支持隐式类型转换，被编译器优化了，所以没有析构
	const Date& d5 = { 2025, 11, 2 };

	list<A> lt;
	//void push_back(const A& aa);
	A aa1(1);
	lt.push_back(aa1);
	lt.push_back(A(2));
	lt.push_back(3);

	list<Date> lt1;
	Date d6(2025, 11, 2);
	lt1.push_back(d6);

	lt1.push_back(Date(2025, 11, 2));//先生成匿名对象，再拷贝构造给vector，所以会析构
	lt1.push_back({ 2025, 11, 2 });

	return 0;
}

static****成员

cpp 复制代码 
class A
{
public:
	A() { ++count; }
	A(const A& t) { ++count; }
	~A() {
		cout << "~A()" << endl;
	}

	// 静态成员函数，特点：没有this指针
	static int GetCount()
	{
		return count;
	}

private:
	// 声明
	static int count;
	int _a = 0;
};

// 定义
int A::count = 0;

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

int main()
{
	//A::count++;

	//cout << sizeof(A) << endl;

	//A aa;
	func();
	func();
	func();


	//A::count++;

	// 公有
	// 属于整个类，属于这个类所有对象
	// 受访问限定符限制
	//cout << A::count << endl;
	//cout << aa.count << endl;

	 A aa;//有名对象
	A aa;  //为了调用而创建的，所以要-1
	cout << aa.GetCount()-1 << endl;


	// A() 这种写法叫做匿名对象，生命周期只在这一行
	cout << A().GetCount() - 1 << endl;

	cout << A::GetCount() << endl;
	cout << A().GetCount() << endl;

	// 总结一下：静态成员函数和静态成员变量，本质受限制的全局变量和全局函数
	// 专属这个类，受类域和访问限定符的限制
	return 0;
}

静态成员变量在类内声明，在类外定义，（因为要走初始化列表，静态成员是类每个对象的公有，不能走初始化列表）

静态成员变量本质也是受类访问限定符限制的变量，在类外不能访问，需要用静态成员函数或者非静态成员函数，再或者将private私有取消才能访问

静态成员函数本质也是受类域限定，属于所有对象，并且没有this指针，不能在静态成员函数内部访问非静态成员变量和函数


【问题】

  1. 静态成员函数可以调用非静态成员函数吗？不可以，没有this指针
  1. 非静态成员函数可以调用类的静态成员函数吗？可以，静态成员函数所有对象共享，在类内类外都能访问
    求1+2+3+...+n_牛客题霸_牛客网求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、swit。题目来自【牛客题霸】https://www.nowcoder.com/practice/7a0da8fc483247ff8800059e12d7caf1?tpId=13&tqId=11200&tPage=3&rp=3&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

这道oj可以用静态方式求解

友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为： 友元函数 和 友元类
友元函数
问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的 输出流对象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作数了。但是实际使用中cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。

cpp 复制代码 
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 关键字。

cpp 复制代码 
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;
}

友元函数很简单，就是在类内声明，在类外可以用这个类的私有成员，并且友元函数是实现在全局的，没有this指针

友元函数的一些说明

友元类（了解）
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述 Time 类和 Date 类，在 Time 类中声明 Date 类为其友元类，那么可以在 Date 类中直接
访问 Time 类的私有成员变量，但想在 Time 类中访问 Date 类中私有的成员变量则不行。
友元关系不能传递
如果 C 是 B 的友元， B 是 A 的友元，则不能说明 C 时 A 的友元。
友元关系不能继承，在继承位置再给大家详细介绍。

cpp 复制代码 
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;
};

内部类

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

  1. 内部类可以定义在外部类的 public 、 protected 、 private 都是可以的。
  2. 注意内部类可以直接访问外部类中的 static 成员，不需要外部类的对象 / 类名。
  3. sizeof( 外部类 )= 外部类，和内部类没有任何关系
cpp 复制代码 
class A
{
private:
	int h;
public:
	// A和B关系
	// B就是一个普通类，只是受A的类域和访问限定符限制,本质相当于被封装了一下

	// B天生就是A的友元
	class B 
	{
	public:
		void func()
		{
			A aa;
			// B天生就是A的友元
			aa.h++;
		}
	private:
		int _b;
	};
};

int main()
{
	cout << sizeof(A) << endl;

	A aa;
	A::B bb;

	return 0;
}

可以看到内部类不算大小，只有外部类的成员int 4字节

并且内部类天生是外部类的友元，可以随意访问外部类的私有成员

内部类受外部类访问限定符的限制，在外部类外边想用内部类创建对象还要指定类域，因为编译器默认只会在全局找B类，不会突破类域A找B

内部类的作用就是，可以将内部类设置为私有，这样只有A类可以用内部类B，外边无法访问

匿名对象

cpp 复制代码 
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};
int main()
{
	A aa1;
	// 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	A();
	A aa2(2);
	// 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);
	return 0;
}

匿名对象特点是类名()，生命周期只有这一行，这一行结束会调用析构函数

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

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。
用代码解释

cpp 复制代码 
#include<iostream>
// 扩展：一些构造时的优化，不同的编译器可能会不同（了解一下）
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;

		if (this != &aa)
		{
			_a = aa._a;
		}

		return *this;
	}

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

int main()
{
	// 1、先用1构造一个临时对象 2、再用临时对象拷贝构造aa1
	// 3、同一个表达式中，连续构造+构造/构造+拷贝构造/拷贝构造+拷贝构造会合二为一
	// a、构造+构造->构造
	// b、构造+拷贝构造->构造
	// c、拷贝构造+拷贝构造->拷贝构造
	A aa1 = 1;  
	const A& aa2 = 2;

	return 0;
}

可以看到确实将构造和拷贝构造合二为一了，只有构造

cpp 复制代码 
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;

		if (this != &aa)
		{
			_a = aa._a;
		}

		return *this;
	}

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

void func(A aa1)
{

}

int main()
{
	// 构造
	A aa(1);
	// 拷贝构造
	func(aa);

	//构造+拷贝构造->构造 
	func(A(2));

	//构造+拷贝构造->构造 
	func(3);

	return 0;
}

可以看到构造+拷贝构造确实被优化成直接构造了，出func函数作用域aa1对象销毁，所以会析构
感谢支持！！！类和对象全集到此结束，有问题可以私信或者评论区，欢迎友好交流

相关推荐
w(ﾟДﾟ)w吓洗宝宝了31 分钟前
组合模式 - 组合模式的实现
c++·组合模式
简 洁 冬冬1 小时前
Java中的Servlet
java·开发语言·servlet
matlabgoodboy2 小时前
留学生scratch计算机haskell函数ocaml编程ruby语言prolog作业VB
开发语言·后端·ruby
R三哥哥啊3 小时前
【Qt】06－对话框
开发语言·qt·microsoft·qt5
hefaxiang3 小时前
【C++】类和对象（一）
开发语言·c++
i_kmling4 小时前
Leetcode 119. 杨辉三角 II
c++·python·算法·leetcode
爱学习的大牛1234 小时前
安卓通过网络获取位置的方法
开发语言·android 网络定位
_extraordinary_4 小时前
C++红黑树详解
c++·红黑树·二叉搜索树·avl树·旋转
SomeB1oody5 小时前
【Rust自学】15.7. 循环引用导致内存泄漏
开发语言·后端·rust
graceyun5 小时前
C语言初阶力扣刷题——349. 两个数组的交集【难度：简单】
c语言·开发语言·leetcode
热门推荐
01SQL从入门到实战-202centos7 init.d 和system.d03Dell服务器升级ubuntu 22.04失败解决04flask-admin 在modelview 默认视图下重写create_model_actions来实现列表数据的批量处理actions05xgboost: Why not implement distributed XGBoost on top of spark06半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)07MIT S081 Lab 2 System Calls08密码学原理技术-第六章-introduction to pulibc-key cryptography09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10小米路由器简单救砖