上传文件至 '对象的初始化和清理2'

对象的初始化和清理2/6、初始化列表.cpp

@@ -0,0 +1,65 @@
+//4、2、6  初始化列表
+
+//作用：C++提供了初始化列表语法，用来初始化属性
+
+//语法：构造函数():属性1(值1),属性2(值2)...{}
+
+#if(0)
+
+
+#include <iostream>
+
+//初始化列表
+class Person
+{
+public:
+
+	//传统的初始化操作
+	//Person(int a, int b, int c)
+	//{
+	//	m_A = a;
+	//	m_B = b;
+	//	m_C = c;
+	//}
+
+	//初始化列表 初始化属性
+	Person(int a,int b,int c) :m_A(a), m_B(b),m_C(c)
+	{
+
+	}
+
+	int m_A;
+
+	int m_B;
+
+	int m_C;
+
+};
+
+
+void test01()
+{
+	//Person p(10, 20, 30);
+	
+	Person p(30,20,10);
+
+	std::cout << "m_A = " << p.m_A << std::endl;
+	std::cout << "m_B = " << p.m_B << std::endl;
+	std::cout << "m_C = " << p.m_C << std::endl;
+
+}
+
+int main()
+{
+	test01();
+
+	
+	system("pause");
+
+	return 0;
+
+}
+
+
+
+#endif

对象的初始化和清理2/7、类作为对象成员.cpp

@@ -0,0 +1,78 @@
+//4.2.7 类作为对象成员
+
+//C++类中的成员可以是另一个类的对象，我们称该成员为对象成员
+
+//例如：
+//class A {}
+//class B
+//{
+//	A a;	
+//}
+
+
+//B类中有对象A作为成员，A为对象成员
+//那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？
+
+#if(0)
+
+#include <iostream>
+
+class Phone
+{
+public:
+	Phone(std::string pName)
+	{
+		m_PName = pName;
+		std::cout << "Phone的构造函数的调用" << std::endl;
+	}
+	~Phone()
+	{
+		std::cout << "Phone析构函数的调用" << std::endl;
+	}
+		
+	std::string m_PName;
+
+};
+
+class Person
+{
+public:
+	Person(std::string name, std::string pName):m_Name(name),m_Phone(pName)
+	{
+		std::cout << "Person的构造函数的调用" << std::endl;
+	}
+	~Person()
+	{
+
+		std::cout << "Person的析构函数调用" << std::endl;
+
+	}
+	//姓名
+	std::string m_Name;
+	//手机
+	Phone m_Phone;
+};
+
+//当其他类对象作为本类成员，构造是侯先构造类对象，再构造自身
+//析构的顺序？
+//析构数顺序与构造相反
+
+void test01()
+{
+
+	Person p("张三", "苹果MAX");
+
+	std::cout << p.m_Name << "拿着一个" << p.m_Phone.m_PName << std::endl;
+}
+
+int main()
+{
+	test01();
+
+	system("pause");
+
+	return 0;
+
+}
+
+#endif

对象的初始化和清理2/8、静态成员1.cpp

@@ -0,0 +1,72 @@
+//4.2.8 静态成员
+
+//静态成员就是在成员变量和成员函数前加上关键字ststic，称为静态成员
+//静态成员分为：
+
+//⚪静态成员变量
+//->所有对象共享同一份数据
+//->在编译阶段分配内存
+//->类内声明，类外初始化
+
+//⚪静态成员函数
+//->所有对象共享同一个函数
+//->静态成员函数只能访问静态成员变量
+
+#if(0)
+
+#include <iostream>
+
+class Person
+{
+public:
+	//1、所有对象都共享同一分数据
+	//2、在编译阶段就分配了内存
+	//3、类内声明，类外初始化操作
+	static int m_A;
+
+	//静态成员变量也是有访问权限的
+private:
+	static int m_B;
+};
+
+int Person::m_A = 100;
+int Person::m_B = 200;
+
+void test01()
+{
+	Person p;
+	//100
+	std::cout << p.m_A << std::endl;
+
+	Person p2;
+	p2.m_A = 200;
+
+	std::cout << p.m_A << std::endl;
+	//std::cout << p.m_B << std::endl           类外访问不到私有静态成员变量
+
+}
+
+void test02()
+{
+	//静态成员变量  不属于某个对象上，所有对象都共享同一份 数据
+	//因此静态成员变量有两种访问方式
+
+	//1、通过对象进行访问
+	//Person p;
+	//std::cout << p.m_A << std::endl;
+	//2、通过类名进行访问
+	std::cout << Person::m_A << std::endl;
+}
+
+
+int main()
+{
+	//test01();
+	test02();
+
+	system("pause");
+
+	return 0;
+}
+
+#endif

对象的初始化和清理2/9、静态成员2.cpp

@@ -0,0 +1,54 @@
+//⚪静态成员函数
+//->所有对象共享同一个函数
+//->静态成员函数只能访问静态成员变量
+
+#include <iostream>
+
+class Person
+{
+public:
+	//静态成员函数
+	static void func()
+	{
+		m_A = 100;                    //静态成员函数可以访问  静态成员变量
+		//m_B = 200;                    //静态成员函数   不可以访问非静态成员变量
+		std::cout << "static void func 函数的调用" << std::endl;
+	}
+
+	static int m_A;                   //静态成员变量
+	int m_B;
+
+	//静态成员函数也是有访问权限的
+private :
+	static void  func2()
+	{
+		std::cout << "static void func2的调用" << std::endl;
+	}
+};
+
+int Person::m_A = 0;
+
+
+//有两种访问方式
+void test01()
+{
+
+	//1、通过对象进行访问
+	Person p;
+	p.func();
+
+	//2、通过类名进行访问
+	Person::func();
+	
+	
+	//Person::func2();        类外访问不到私有静态成员函数
+}
+
+int main()
+{
+	test01();
+
+	system("pause");
+
+	return 0;
+}