C++类和对象 - 下【匿名对象，友元，static成员】

#include<iostream>
using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)
		,_a2(_a1)
	{}

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

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

int main()
{
	A aa(1);
	aa.Print();
}

#include<iostream>
using namespace std;
class A
{
public:
	// 构造函数explicit就不再⽀持隐式类型转换
	// explicit A(int a1)
	A(int a1)
		:_a1(a1)
	{
		cout << "构造函数:A(int a1)" << endl;
	}

	//拷贝构造
	A(const A& d)
		:_a1(d._a1)
		, _a2(d._a2)
	{
		cout << "拷贝构造:A(const A& d)" << endl;
	}

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

	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "构造函数:A(int a1,int a2)" << endl;
	}
	int Get() const
	{
		return _a1 + _a2;
	}

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

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

class Stack
{
public:
	void Push(const A& aa)
	{}
//...
};
// 内置类型 -> 自定义类型的转换
// 自定义类型 -> 自定义类型转换
int main()
{
	// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3
	// 编译器遇到连续构造+拷⻉构造->优化为直接构造
	/*A aa1 = 1;
	aa1.Print();

	const A& aa2 = 1;*/

	A aa3 = { 2,2 };
	const A& aa4 = { 1,1 };

	//栈
	Stack st;
	/*A aa5(5);
	st.Push(aa5);*/
	st.Push(5);

	/*A aa6(6,6);
	st.Push(aa6);*/
	st.Push({ 6,6 });

	// aa3隐式类型转换为b对象
    // 原理跟上⾯类似
	B b = aa3;
	const B& rb = aa3;

	return 0;
}

class Date
{
public:
	Date(int& x, int year = 1, int month = 1, int day = 1)
	{
	}
private:
	int _year;
	int _month;

	//静态成员变量
	static int _day;

};

//必须要在类外进行初始化
int Date::_day = 10;

int main()
{
	Date d1();
	return 0;
}

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(10)
		,_month(7)
	{
	}
	//静态成员函数
	const int Print() 
	{
		return _day;
	}

private:
	int _year = 12;
	int _month = 6;

	//静态成员变量
	static int _day;

};

//必须要在类外进行初始化
int Date::_day = 10;

void fun()
{
	//如果是一个函数的话我们用，对象.静态成员函数，还要创建一个对象太麻烦了。
	
	//可以使用类名::静态成员函数
	cout << Date::Print << endl;
}

int main()
{
	Date d1;
	//对象.静态成员函数
	cout << d1.Print() << endl;

	return 0;
}

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
		:_year(10)
		,_month(7)
	{
	}
	//静态成员函数
	const int Print() 
	{
		return _day;
	}

private:
	int _year = 12;
	int _month = 6;

	//静态成员变量
	static int _day;
	//static int _day = 10;

};

//必须要在类外进行初始化
int Date::_day = 10;

void fun()
{
	//如果是一个函数的话我们用，对象.静态成员函数，还要创建一个对象太麻烦了。
	
	//可以使用类名::静态成员函数
	cout << Date::Print << endl;
}

int main()
{
	Date d1;
	//对象.静态成员函数
	cout << d1.Print() << endl;

	return 0;
}

#include <type_traits>
class add{
public:
   //构造函数
   add()
   {
       //每调用一次，d2都会加d1
       d2 = d2 + d1;
       d1++;
   }
   //静态成员函数
   static int tab()
   {
      return d2;
   }
private:
//静态成员
 static int d1;
 static int d2;
};
//静态成员初始化d1和d2
int add::d1 = 1;
int add::d2 = 0;
 
class Solution {
public:
    int Sum_Solution(int n) {
        //这里的n，是有n个对象，每个对象都会调用构造函数
        add ss[n];
        //返回d2的值
        return add::tab();
    }
};

A：D B A C
B：B A D C
C：C D B A
D：A B D C
E：C A B D
F：C D A B  


C c;
int main()
{
A a;
B b;
static D d;
return 0；
}

#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;
}

#include<iostream>
using namespace std;

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;
}

class A
{
	//在A内部定义B
	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;
	};


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

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

	A aa;
	A::B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

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(1);
	A();
	A aa2(2);
	// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
	Solution().Sum_Solution(10);

    //Solution dd;
    //dd.Sum_Solution(5);

	return 0;
}

class A
{
public:

private:
	int _a;
};

class Solution {
public:
    //类类型缺省参数
	void  Sum_Solution(const A& d = A()) 
	{
		//..
	}
};
int main()
{  
    A aa1;

    Solution().Sum_Solution(aa1);

	return 0;
}

#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(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)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 隐式类型，连续构造+拷⻉构造->优化为直接构造
	f1(1);
	// ⼀个表达式中，连续构造+拷⻉构造->优化为⼀个构造
	f1(A(2));
	cout << endl;
	cout << "***********************************************" << endl;
	// 传值返回
// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
	f2();
	cout << endl;
	// 返回时⼀个表达式中，连续拷⻉构造+拷⻉构造->优化⼀个拷⻉构造 （vs2019 debug）
	// ⼀些编译器会优化得更厉害，进⾏跨⾏合并优化，直接变为构造。（vs2022 debug）
	A aa2 = f2();
	cout << endl;
	// ⼀个表达式中，连续拷⻉构造+赋值重载->⽆法优化
	aa1 = f2();
	cout << endl;
	return 0;
}