C++类和对象(4)

XiaoCCCcCCccCcccC

已于 2024-08-19 17:17:15 修改

阅读量339

点赞数 5

文章标签：开发语言 c++

于 2024-08-19 17:16:41 首次发布

本文链接：https://blog.csdn.net/CSQCSQCC/article/details/141327773

版权

1.类型转换

(1)C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。

(2)构造函数前面加explicit就不再支持隐式类型转换。

(3)类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

下列的代码中实现的就是在创建类对象时，用int进行隐式转换构造A这个类的类对象。下列代码中的第2，3，4种均为隐式类型转换进行的构造。

class A
{
public:
	// explicit A(int a1)    //构造函数前加explicit就不在支持隐式类型转换
	 A(int a1) //如果要使用int类型进行隐式转换，构造函数的参数要有int类型
		:_a1(a1)
	{}
	//explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}
	void Print() const
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	//1.这个调用的是构造函数进行初始化
	A aa1(1);
	aa1.Print();

	//2. int类型2构造一个A的临时对象，再用这个临时对象拷贝构造aa2
    //这里按照语法来看是拷贝构造，但是赋值运算符右边并不是A类型的对象，而是一个int对象
    //所以这里进行了隐式转换，先用2这个int类型的对象构造一个A类型的临时对象，再这个临时
    //对象构造aa2
    //编译器遇到连续构造+拷⻉构造->优化为直接构造(调试时只能看到进行直接构造)
	A aa2 = 2;
	aa2.Print();

    //3.临时变量具有常性，要用const进行修饰来引用
	const A& aa3 = 1; //需要加const才能进行类型的引用，因为是用临时对象拷贝构造的aa3,所以具有常性
	aa3.Print();

	//4.C++11之后才⽀持多参数转化
	A aa4 = { 2,2 };
	aa4.Print();
	return 0;
}

2.static成员

2.1static成员

(1)用static修饰的成员变量。称之为静态成员变量，静态成员变量一定要在类外进行初始化。

(2)静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。

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

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

(5)⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

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

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

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

//实现一个类，计算程序中创建了多少个类对象
#include <iostream>
using namespace std;

class A
{
public:
	A()
	{
		++_scount;
	}

	A(const A& t) //拷贝构造
	{
		++_scount;
	}

	~A()
	{
		--_scount;
	}

	int GetCount1()
	{
		return _scount;
	}

	static int GetCount2()
	{
		return _scount;
	}

private:
	//类里面声明
	static int _scount;
};

//类外面初始化
//因为属于静态区，不属于某个类对象，所以用类名::静态成员进行初始化
int A::_scount = 0;

int main()
{
	//如果是非静态函数只能先创建变量再访问成员函数
	A aa1;
	cout << aa1.GetCount1() << endl;

	//如果是静态函数,可以用类名::静态成员 也可以用 对象.静态成员 
	cout << A::GetCount2() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetCount2() << endl;
	cout << a1.GetCount2() << endl;

	//静态成员也是类的成员，受访问限定符的限制
	//cout << A::_scount << endl;

	return 0;
}

2.2 求1+2+3+...+n

求1+2+3+...+n_⽜客题霸_⽜客⽹，该题不允许使用常规的方法，在这里我们的想法是，创建一个Sum类对象，就调用一次Sum对象的构造函数，调用一次就使内部的静态成员_i++,_ret += _i,最后返回_ret,实现1+2+3+...+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();
    }
};

3.友元

(1)友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。

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

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

(4)⼀个函数可以是多个类的友元函数。

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

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

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

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

下列代码介绍友元函数：

#include <iostream>
using namespace std;

//前置声明，因为A类中的友元函数func的形参中有B类的引用
class B;

class A
{
	//在A类中声明了func是友元函数，则A把func认为是朋友，故A允许func使用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 << " " << aa._a2 << endl;
	cout << bb._b1 << " " << bb._b2 << endl;
}

int main()
{
	A aa;
	B bb;
	func(aa, bb);

	return 0;
}

下列代码介绍友元类：

#include<iostream>
using namespace std;
class A
{
	// 友元声明
	//这里A类把B类当作朋友。所以B类中的成员函数被允许访问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.func2(aa);
	return 0;
}

4.内部类

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

(2)内部类默认是外部类的友元类。意思是内部类可以访问外部类的私有成员变量。

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

#include<iostream>
using namespace std;
class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B // B默认就是A的友元
	{
	public:
		void foo(const A& a)
		{
			cout << _k << endl; //OK
			cout << a._h << endl; //OK
		}
	};
};

int A::_k = 1;

int main()
{
	cout << sizeof(A) << endl; //内部类和静态成员变量都不算在A里面，故A的大小为4
	A::B b;
	A aa;
	b.foo(aa);
	return 0;
}

#include <iostream>
#include <stdio.h>
using namespace std;
class Solution {
	//内部类,这里的Sum主要是给Solution用的
	class Sum //Sum类使用Solution类的变量_i和_ret
	{
	public:
		Sum()
		{
			_ret += _i;
			++_i;
		}
	};

	static int _i;
	static int _ret;

public:
	int Sum_Solution(int n)
	{
		int i = 0;
		while (i < n)
		{
			Sum arr1[1];
			i++;
		}

		//Sum arr[n]; //变长数组
		return _ret;
	}
};

int Solution::_i = 1;
int Solution::_ret = 0;

int main()
{
	Solution s1;
	cout << s1.Sum_Solution(3) << endl;
	return 0;
}

5.匿名对象

(1)⽤ 类型(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 类型对象名(实参) 定义出来的叫有名对象。

(2)匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。

#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

class Solution
{
public:
	Solution()
	{
		cout << "Solution()" << endl;
	}

	~Solution()
	{
		cout << "~Solution()" << endl;
	}

	int Sum_Solution(int n)
	{
		//...
		return n;
	}
};

int main()
{
	A aa1;

	//匿名对象的特点不用取名字，但是生命周期只有一行
	A();
	A(1);

	A aa2(2);

	cout << Solution().Sum_Solution(10) << endl; //生命周期只有1行

	return 0;
}

6.对象拷贝时的编译器优化

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

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

下列的代码是在VS2022版本的编译器下实现的，不同的编译器优化不同，下列的结果仅供参考。下列部分了解即可。

#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0) //默认构造函数
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}

	A(const A& aa) //拷贝构造
		:_a1(aa._a1)
	{
		cout << "A(cosnt 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)
{}

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

int main()
{
	//传值传参
	A aa1; //进行一次构造
	f1(aa1); //进行一次拷贝构造
 	//不会被优化
	cout << endl;

	//隐式类型转换：
	//f1(1)是隐式类型转换(一次构造+一次拷贝构造)+传值传参转换(一个拷贝构造)，生命周期只有1行，
	//原本应该为构造函数+拷贝构造+拷贝构造->优化为直接构造
	f1(1);
	cout << endl;

	//原本应该为构造函数+拷贝构造->优化为直接构造
 	//下列是匿名构造+传值传参
	f1(A(2));
	cout << endl;

	cout << "*****************************************************" << endl;

	//传值返回
 	//vs2019下不优化
	// 返回时⼀个表达式中，直接构造+拷⻉构造->优化⼀个直接构造
	f2();
	cout << endl;

	//f2()中有一个构造+一个拷贝构造，这行代码也是一个拷贝构造->直接优化为一个构造
 	//则为直接构造+拷贝构造+拷贝构造->直接优化为一个直接构造 
	A aa2 = f2();
	cout << endl;

	//一个表达式中，构造+拷贝构造+赋值重载->其中的拷贝构造被优化了，赋值重载没有优化->优化为一个直接构造+一个赋值重载
	A aa3;
	aa3 = f2();
	cout << endl;

	return 0;
}

XiaoCCCcCCccCcccC

关注

5
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
C++类和对象(4)

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

扫一扫