类和对象（下）：static成员、友元类、内部类、匿名对象、优化——对象拷贝时的编译器优化

用户11831438

发布于 2025-12-30 14:02:30

940

一、static 成员

1.1 知识点讲解

用static修饰的成员变量，称之为静态成员变量。

嗯？这是什么意思？ok，我们通过代码就可以很清晰的看出其中的意思：

这时候就有uu想问了，当我们计算这个类的大小的时候，静态成员变量的大小有没有被计算在内？ 其实是没有的，静态成员变量为所有类对象共享的，不属于某个具体的对象，并且是不存在对象中的，而是存放在静态区，生命周期是全局的，只是受到类域和访问限定符的限制

ok，既然我们已经知道如何在一个类中写一个静态成员变量，那我们该如何使用呢？

静态成员变量的使用是通过类名::静态成员或者对象.静态成员或者类型指针 -> 静态成员来访问静态成员变量

那让我们尝试使用一下静态成员变量：

那这里为什么会报错呢？——

这是因为当静态成员变量属于私有的时候，类外是不能使用，只能在类里面可以使用，所以如果我们想要访问静态成员变量，可以将静态成员变量放在共有的位置

通过上面的操作，我们就可以访问了

但是当我们运行上面的代码时还是会报错，这又是什么原因？

那我们该怎么定义静态成员变量并在定义时初始化静态成员变量呢？

静态成员变量是属于整个类，属于私有时，使用访问限定符无法访问；只有当属于公有时才可以访问。

那这里博主就有个问题：如果是这样的话，那如果我们非得将静态成员变量放在私有，我们该怎么访问这个静态成员变量？ 这时我们可以在类中写一个成员函数，并让static修饰这个成员函数，这样就可以通过通过类名::静态成员函数或者对象.静态成员函数或者类型指针 -> 静态成员函数对属于私有的静态成员变量进行访问：

注意：

用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。

但是非静态的成员函数，可以访问任意的静态成员变量和静态成员函数！！！

这里就不能使用类名::静态成员函数，：：这样访问，只能访问静态成员函数或者变量的。

突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
静态成员也是类的成员，受public、protected、private 访问限定符的限制。

注意： 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

1.2 题目

求1+2+3+……+n

代码：

#include <regex>
class Sum
{
public:
    Sum()
    {
        _ret+=_i;
        _i++;
    }
    static int get_num()
    {
        return _ret;
    }
private:
    static int _i;
    static int _ret;
};
int Sum::_i=1;
int Sum::_ret=0;
class Solution {
public:
    int Sum_Solution(int n) {
        Sum arr[n];
        return Sum::get_num();
    }
};

二、友元类（“轻度社交”）

友元提供了一种突破类访问限定符封装的⽅式

友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。

2.1 友元函数

当一个类外的函数想要访问类里面的私有成员变量时，我们就可以让这个函数成为这个类的友元函数，这样这个函数就是这个类的朋友，（是我的朋友就可以访问我的私有成员），并且一个函数可以成为多个类的友元。

代码演示：

我们看到当func函数想要访问类中的私有成员_a1，_b1，就必须让该func 函数成员这两个类的友元，这样就可以访问了。

但是上面的代码还是有一点错误：

所以我们需要给B这个类搞个前置声明，让编译器知道我这个B是一个类！！！

正确代码：

class B;
class A
{
public:
	friend void func(const A& aa, const B& bb);
private:
	int _a1 = 1;
	int _a2 = 1;
};
class B
{
	friend void func(const A& aa, const B& bb);
private:
	int _b1 = 1;
	int _b2 = 2;
};
void func(const A& aa, const B& bb)
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}
int main()
{
	A aa1;
	B bb1;
	func(aa1, bb1);
	return 0;
}

2.2 友元类

当我们需要在一个类中大量访问另一个类中的东西，就可以将这个类变成友元类

对于上面这种，我们也可以让D中需要访问到C类中的私有成员的函数成为C的友元函数，但是如果有多个函数，此时就比较麻烦。

这时候就会有同学想问了：这里不需要在class C的前面加上class D的声明吗？ ok，这里是不需要的，因为友元函数仅仅是⼀种声明，友元声明可以是前置声明，友元函数不是类的成员函数

注意：

友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。

友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。

友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。

2.3 成为互相的友元

C是D的友元，D是C的友元。但是当我们运行上面的代码，会发现编译器怎么又报错了？（博主写到这快要崩了😭），这是因为：

所以我们要将声明和定义分离：

//声明
class C
{
	friend class D;
public:
	//声明
	void func3(const D& dd);
	void func4(const D& dd);
private:
	int _c1 = 2;
	int _c2 = 3;
};
class D
{
	friend class C;
public:
	void func1(const C& cc);
	void func2(const C& cc);
private:
	int _d1 = 4;
	int _d2 = 5;
};
//定义
void D::func1(const C& cc)
{
	cout << cc._c1 << endl;
	cout << _d1 << endl;
}
void D::func2(const C& cc)
{
	cout << cc._c2 << endl;
	cout << _d2 << endl;
}
void C::func3(const D& dd)
{
	cout << dd._d1 << endl;
	cout << _c1 << endl;
}
void C::func4(const D& dd)
{
	cout << dd._d2 << endl;
	cout << _c2 << endl;
}
int main()
{
	C cc;
	D dd;
	dd.func1(cc);
	dd.func2(cc);
	cc.func3(dd);
	cc.func4(dd);
	return 0;
}

我们可以将声明放到.h文件中，定义放到.cpp文件中！！！

三、内部类

博主第一次看到这个，就想起了，这是不是在问我们“累不累”（好累啊！！！）

那啥是内部类呢？

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在全局的类相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。
内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地放都用不了。