目录

 

一，类型转换

二，static成员

三，友元

四，内部类

五，匿名对象

六，对象拷贝时的编译器优化

---

一，类型转换

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

2，构造函数前面可以加上explicit就不在支持隐式类型转换。

3，类类型之间也可以进行隐式类型转换，不过需要构造函数进行支持。

类型转换的目的主要是用来简化内容，减少创建类类型的变量

class A
{
public:
	A(int a1 = 0)
		:_a1(a1)
	{}
	//多参数类型的构造函数
	A(int a1, int a2)
		:_a1(a1)
		,_a2(_a1)
	{}
	//拷贝构造函数
	A(const A& a)
	{
		_a1 = a._a1;
	}
	void Printf()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 1;
};
//栈类
class Stack
{
public:
	void Push(const A& a)
	{

	}
private:
	A arr1[10];
	int _top;
};
int main()
{
	//2先放到临时对象当中，再拷贝构造为A类型
	A ass1 = 1;
	ass1.Printf();
	A& as1 = ass1;//拷贝构造
	//临时变量具有常性需要加const
	const A& as2 = 2;

	int i = 12; 
	double k = i;//同理i先放到临时对象当中
	const double& rd = i;

	Stack st;
	A a2(2);
	st.Push(a2);
	//不用创建a2就可以达到相同的效果--达到简化的效果
	st.Push(2);

	//多参数的类型转换 
	A sa = { 1,2 };
	st.Push(sa);
	//同样可以简化为：
	st.Push({ 2,3 });
	return 0;
}

二，static成员

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

2，静态成员变量为所有类类型的对象所共享，不属于某个对象，存在静态区。

3，用static修饰的成员函数称为静态成员函数，静态成员函数的参数中没有this指针，因为他不属于某个类对象。

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

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

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

下面在main主函数当中进行演示

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

使用：

//计算程序中创建了多少个类
class A
{
public:
	A()
	{
		count++;
	}
	A(const A& n)
	{
		count++;
	}
	~A()
	{
		count--;
	}
	//设置静态函数绕过访问限定符得到静态成员变量
	static int Getcount()
	{
		//a++;  //不能访问到a
		return count;
	}
	//在类中的其他成员可以任意访问静态成员变量和函数
	void Func()
	{
		cout << count << endl;
		cout << Getcount << endl;
	}
private:
	static int count;
	int a = 1;
};
//静态成员变量在类外面进行初始化
int A::count = 0;

int main()
{
	//cout << A::count << endl; //不能直接访问
	//借助静态成员函数进行访问
	cout << A::Getcount() << endl;
	A a1, a2;
	{
		A a3(a1);
		cout << A::Getcount() << endl;
	}
	cout << A::Getcount() << endl;
	cout << a1.Getcount() << endl;
	return 0;
}

运行结果：0 3 2 2

例题1：

class Sum
{
public:
    Sum()
    {
        count += i;
        i++;
    }
    static int Getcount()
    {
        return count;
    }
private:
    //使用静态变量使其为全局变量
    //每进行一次Sum函数就可以记录 
    static int i;
    static int count;
};
int Sum::i = 1;
int Sum::count = 0;
class Solution {
public:
    int Sum_Solution(int n) 
    {
        //定义一个变长数组,当执行sum函数n次时，count就是要求的值
        Sum arr[n];
        return Sum::Getcount();
    }
};

例题2：

先构造全局变量C,再进入主函数按照顺序构造a，b，d

对于析构顺序是构造函数的相反，同时由于全局变量创建后主函数开辟的函数栈帧，所以先在主函数中析构b，再析构a,静态局部变量在main执行之后全局变量之前析构，最后析构全局c

答案：E B

三，友元

1，友元的作用：允许一个外部函数或另一个类来突破private和protected的限制访问当前类的成员，友元分为：友元函数和友元类。用法：在函数声明前加上friend,并把友元声明放到一个类中。

注意：友元函数不是类的成员函数

2，友元函数可以在类的任何地方进行声明，不受访问限定符的影响。

3，一个函数可以是多个类的友元函数，即一个函数可以访问多个类中的成员或函数。

class B;
class A
{
	friend void Func(const A& a, const B& b);
private:
	int _a1 = 4;
	int _a2 = 3;
};
class B
{
	friend void Func(const A& a, const B& b);
private:
	int _b1 = 3;
	int _b2 = 4;
};
//可以访问类A和类B
void Func(const A& a, const B& b)
{
	cout << a._a1 << endl;
	cout << b._b2 << endl;
}
int main()
{
	A a;
	B b;
	Func(a, b);	
	return 0;
}

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

5，友元类的关系是单向的，没有交换性。例如:A类是B类的友元，但是B类不是A类的友元。则

A类可以使用B类中的私有成员，而B类不能使用A类当中的私有成员。

6，友元关系不能进行传递，例如A类是B类的友元，B类是C类的友元，但是A类不是C类的友元。

类比：友元类就相当于我是你的朋友，我可以去到你家拿取东西，但是你不是我的朋友，你不能到我家拿取东西。同时A是B的朋友，B是C的朋友，但是A不一定是C的朋友。

class A
{
public:
	//友元类
	friend class B;
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	//可以访问到类A中的成员
	void Func1(const A& a)
	{
		cout << a._a1 << endl;
		cout << _b1 << endl;
	}
	void Func2(const A& a)
	{
		cout << a._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A ar;
	B b3;
	b3.Func1(ar);
	b3.Func2(ar);
	return 0;
}

四，内部类

如果一个类定义在另一个类中，那么这个类被称为内部类。内部类是一个独立的类，跟全局相比，只是受到了类域和访问限定符的影响，同时计算类的大小时，不会算上内部类。

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

内部类本质上是一种封装，当A类和B类紧密联系，A类实现出来主要是给B类进行使用 ，就可以把A类放到B类当中，如果放到private/protect当中，A类就是B类专属内部类，其他地方不能使用 。

运用展示：

class A
{
public:
	class B
	{
	public:
		//内部类默认是外部类的友元类
		void Func(const A& a)
		{
			cout << a.a1 << endl;
			cout << a.k << endl;
		}
		 
	private:
		int _b1;
	};
private:
	int a1 = 1;
	static int k;
};
int A::k = 2;
int main()
{
	//大小为4只计入了a1,内部类不进行计入
	cout << sizeof(A) << endl;
	A a;
	A::B rb;
	rb.Func(a);
	return 0;
}

运行结果：

五，匿名对象

相比较之前使用：类型 对象名（参数）定义的有名对象，用类型 （实参）定义出的对象称之为匿名对象。

匿名对象的生命周期和临时变量相同只在当前的一行，当只临时使用一下该类类型时，可以进行使用匿名对象。

使用展示：

class A
{
public:
	A(int a = 1)
		:_a(a)
	{
		cout << "A" << endl;
	}
	~A()
	{
		cout << "~A" << endl;
	}
private:
	int _a;
};
int main()
{
	A ar;
	//定义匿名函数
	//生命周期只有这一行，下一行会自动调用析构函数
	A();
	A(1);
	//A arr()  //不能这样定义，无法识别是函数声明还是对象定义
	A arr(2); //传入实参就可以分辨
	return 0;
}

当一条语句既可以解释为对象定义，又可以解释为函数声明时，编译器必须将其解释为函数声明。

六，对象拷贝时的编译器优化

解释：编译器为了提高程序的效率，在不影响正确性的前提下 ，会尽可能减少传参或传返回值过程中可以省略的拷贝。

使用：

如何进行优化编译器没有进行严格的规定，一般是当在同一行代码中同时调用构造函数和拷贝构造函数时，进行优化为一个构造函数。

功能演示：

class A
{
public:
	//构造函数 
	A(int a1 = 0)
		:_a1(a1)
	{
		cout <<"A(int a1)" << 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;
	}
	//进行打印
	void Print()
	{
		cout << "A::Print->" << _a1 << endl;
	}
	A& operator++()
	{
		_a1 += 100;
		return *this;
	}

private:
	int _a1 = 1;
};

Debug和 Release环境下运行结果相同：

析构总结：函数中的局部变量和参数过了函数就会析构，匿名对象和临时对象的生命周期只在一行，过了这一行，就会析构。main中的变量在return 0前析构