类和对象

薄青

已于 2025-05-02 13:10:10 修改

阅读量678

点赞数 9

分类专栏： C++ 文章标签： c++ 开发语言

于 2025-04-03 11:38:29 首次发布

本文链接：https://blog.youkuaiyun.com/2301_80326627/article/details/146964901

版权

C++ 专栏收录该内容

8 篇文章

订阅专栏

类型转换

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
构造函数前面加explicit就不再支持隐式类型转换。
类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

平时我们常见的类型转换有：整形与整形，整形与浮点型，整形与指针，指针与指针之间；

这里提到的是类类型的转换，先观察main函数内容。

class A
{
public:
	// 构造函数explicit就不再支持隐式类型转换
	// explicit A(int a1)


	A(int a1)
		:_a1(a1)
	{}

	A(const A& aa)
		:_a1(aa._a1)
		,_a2(aa._a2)
	{}

	//explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	// 自定义类型对象 = 内置类型的对象
	A aa1(1);    
	A aa2(1, 1);

	A aa3 = 1;   // 这里会将 1 (int) 转化为 A 类型
	const A& aa4 = 1;

	A aa5 = { 2, 2 };
	const A& aa6 = { 2, 2 };  //C++11支持{}传参，会自动匹配参数位置

	return 0;
}

拓展：

C++进行类型转换时会创建临时变量，临时变量具有常性，所以 A& aa4 前应该加const，否则就会权限放大，编译不通过。

下面是一个Stack类插入时的对象类型转换。

class A
{
public:
	A(int a1)
		:_a1(a1)
	{}

	A(const A& aa)
		:_a1(aa._a1)
		,_a2(aa._a2)
	{}

	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}

	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}

	int Get() const
	{
		return _a1 + _a2;
	}

private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
public:
	B(const A& a)
		:_b(a.Get())
	{}
private:
	int _b = 0;
};

class Stack
{
public:
	void Push(const A& aa)
	{}
};

int main()
{

	Stack st;
	A aa7(7);
	st.Push(aa7);

	A aa8(8, 8);
	st.Push(aa8);

	st.Push(7);
	st.Push({8, 8});


	return 0;
}

使用过 STL地同学可能对这里很眼熟，我们平时用过的STL模板这里就涉及了类型转换。

static成员

用static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进行初始化。
静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

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

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

突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。

静态成员也是类的成员，受public、protected、private 访问限定符的限制。

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

一定要在类外初始化。

class A
{
private:
	// 类⾥⾯声明
	static int _scount;
};

//类外初始化
int A::_scount = 0;

class A
{
public:
	A()
	{
		++_scount;
	}
	A(const A& t)
	{
		++_scount;
	}
	~A()
	{
		--_scount;
	}
	static int GetACount()
	{
		return _scount;
	}
private:
	// 类⾥⾯声明
	static int _scount;
};
// 类外⾯初始化
int A::_scount = 0;
int main()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
	cout << a1.GetACount() << endl;
	// 编译报错：error C2248: “A::_scount”: ⽆法访问 private 成员(在“A”类中声明)
	//cout << A::_scount << endl;
	return 0;
}

静态成员变量还是属于类，不过存在于静态区。

这里给出一个static的用法题

求1+2+3+...+n_牛客题霸_牛客网

该题中禁用了我们日常能用到的循环判断等语法，同时还不能使用递归跟数学方法。不过我们能使用类来解决此题，求 1+2+....+n 的值，只要出现n个值，然后依次相加即可，所以我们只要有n个类，类中的构造函数能自动调用。

class Sum {
  public:
    Sum() {
        _ret += _i;
        ++_i;
    }
    static int GetRet() {
        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::GetRet();
    }
};

友元

友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。

外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。

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

一个函数可以是多个类的友元函数。

友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。

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

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

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

外部友元函数

由下述代码可知，func()函数并不属于类A 和类B 的任意一方的成员函数，但是func() 函数却可以使用 A 和 B 的私有成员变量，这便是友元函数的作用。

#include<iostream>
using namespace std;
// 前置声明，都则A的友元函数声明编译器不认识B
class B;
class A
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
	// 友元声明
	friend void func(const A& aa, const B& bb);
private:
	int _b1 = 3;
	int _b2 = 4;
};
void func(const A& aa, const B& bb)
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}
int main()
{
	A aa;
	B bb;
	func(aa, bb);
	return 0;
}

友元类

下述代码中 B 是 A 的友元类，根据友元的定义，B 可以访问 A 中的成员变量和成员函数，但是相反，A 不能访问 B 中的变量和函数，所以友元类是单向的。

class A
{
	// 友元声明
	friend class B;
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A aa;
	B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

内部类

内部类暂时只做了解，不深入理解。

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。

内部类默认是外部类的友元类。

内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

class B 在class A的内部，外部类可以直接使用内部类，但外部代码需通过外部类名访问（如A::B）；同时内部类的作用域受外部类控制。

class A
{
private:
	static int _k;
	int _h = 1;

public:
	class B //B默认就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << _k << endl; // 
			cout << a._h << endl; //_h是A的内部私有成员变量但可以访问
		}

		int _b1 = 1;
		int _b2 = 1;
	};
};
int A::_k = 1;

int main()
{

	cout << sizeof(A) << endl;
	A::B bb1;

	return 0;
}

注：内部类是外部类的成员类型，而非成员对象。

匿名对象

用类型(实参) 定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名(实参) 定义出来的叫有名对象。
匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

对于定义解释看下述代码注释。

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};


void func1(int i = 0)
{}

int main()
{
    //一般情况下定义对象，可以选择是否初始化
    // 这种就是有名对象
	A aa1;
	A aa2(2);


	// 我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
    // 匿名对象就是没有确定的名字
	A();
	A(1);

    // 这样会出错，因为匿名对象具有常性，不加const 会使权限变大
	A& ref1 = aa1;  

	// const引用会延长匿名对象的声明周期，匿名对象跟着引用走
	const A& ref2 = A();

	return 0;
}

同时匿名对象也可以做缺省参数，注意这里的匿名对象作为形参，应该遵循缺省参数的定义。

	// 匿名对象做缺省参数
	//void func2(const A& aa = A())
	void func2(const A& aa = A(10))
	{}

    int main()
    {

		func2();
		func2(aa1)
        return 0;
    }

对象拷贝时的编译器优化

学习这个知识点要先了解类的构造函数，拷贝构造等知识点。

类的默认成员函数-优快云博客

现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一些传参和传返回值的过程中可以省略的拷贝。

如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续⼀个表达式步骤中的连续拷贝会进行合并优化，有些更新更"激进"的编译器还会进行跨行跨表达式的合并优化。

linux下可以将下面代码拷贝到test.cpp 文件，编译时用 g++ test.cpp -fno-elide constructors 的方式关闭构造相关的优化。

通常会优化的情况：

1.隐式类型，连续构造+拷贝构造->优化为直接构造

2.一个表达式中，连续构造+拷贝构造->优化为一个构造

3.传值返回，不优化的情况下传值返回，编译器会生成一个拷贝返回对象的临时对象作为函数调用表达式的返回值。一些编译器会优化得更厉害，将构造的局部对象和拷贝构造的临时对象优化为直接构造。

隐式类型

连续构造+拷贝构造->优化为直接构造

重点在main()函数中

class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};

void f1(A aa)
{}

int main()
{
	// 构造+拷⻉构造 -> 直接构造
    A aa1 = 1;

    //直接构造
    A aa2(1);

	return 0;
	
}

图示：使用linux关闭编译器优化

表达式传值

连续构造+拷贝构造->优化为一个构造

class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};

void f1(A aa)
{
}

int main()
{
    
    f(1);
    f(A(1));
	return 0;
}

图示：

传值返回

class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};

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

int main()
{
    A aa2 = f(2);
    cout << endl;

	return 0;
}

图示：

拓展：友元类和内部类的区别

（取自deepseek）

友元类（Friend Class）
- 在 C++ 中，通过 friend 关键字声明，允许另一个类访问当前类的 私有（private）和保护（protected）成员。
- 友元关系是单向的，且不传递（如 A 是 B 的友元，B 是 C 的友元，并不意味 A 是 C 的友元）。
- 设计目的：打破封装性，为特定类提供直接访问权限，常用于紧密协作的类（如数据容器与迭代器）。
内部类（Nested Class）
- 定义在另一个类内部的类，属于外部类的成员之一。
- 内部类可以访问外部类的 所有成员（包括私有成员），但需要显式依赖外部类的实例或静态上下文（C++ 中需传递 this 指针，Java 中隐式持有外部类引用）。
- 设计目的：将逻辑相关的类组织在一起，隐藏实现细节（如链表中的 Node 类）。

总结

维度	友元类	内部类
核心目的	授予其他类访问私有成员的权限。	将相关类组织在一起，隐藏实现细节。
封装性	破坏封装，需谨慎使用。	增强封装，逻辑内聚。
关系方向	单向（需显式声明）。	内部类属于外部类的一部分。
典型语言	C++ 支持。	C++、Java、C# 等均支持。