C++ >>类与对象 零碎（没想好怎么取名）

时间：2019年8月22日12:19:19
编译器：vs2017

1. 类对象作为类成员
2. 初始化列表
3. 静态成员函数

类对象作为类成员

#include <iostream>
using namespace std;
#include <string>

//C++ 类中的成员是另一个类的对象， 我们称该成员为对象成员

class Phone
{
public:
	
	Phone(string pName)
	{
		cout << "Phone 的构造函数的调用" << endl;
		m_PNmae = pName;
	}

	~Phone()
	{
		cout << " Phone 析构函数调用 " << endl;
	}

	string m_PNmae;		//手机平牌名称
};


class Person
{
public:
	
	// Phone m_Phone = p.Name   隐式转换法
	Person(string name, string pName): m_Name(name),m_Phone(pName)
	{
		cout << "Person 的构造函数调用" << endl;
	}

	~Person()
	{  
		cout << " Person 析构函数调用 " << endl;
	}

	string m_Name;		//姓名
	Phone m_Phone;		//手机
};

//C++ 类中的成员是另一个类的对象, 先构造类的对象，在构造自身
// 析构的时候， 顺序相反

void test01()
{
	Person p("里昂", "苹果MAX");

	cout << p.m_Name << "拿着：" << p.m_Phone.m_PNmae << endl;
 }

int main()
{
	test01();

	system("pause");
	return 0;
}

初始化列表

#include <iostream>
using namespace std;

// 初始化列表
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);
	cout << " m_A =  " << p.m_A << endl;
	cout << " m_B =  " << p.m_B << endl;
	cout << " m_C =  " << p.m_C << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

静态成员函数

#include <iostream>
using namespace std;

/*
	静态成员就是在成员变量和成员函数前加上关键字 static ，称为静态成员
	1、静态成员变量：
		所有对象共享同一份数据；
		在编译阶段分配内存；
		类内声明， 类外初始化
	2、静态成员函数：
		所有对象共享同一个函数
		静态成员函数只能访问静态成员变量
*/


class Person
{
public:

	//静态成员函数
	static void func()
	{
		m_A = 100;     //静态成员函数可以访问 静态成员变量
		//m_B = 200;    非静态成员函数不可以访问 静态成员变量，无法区分到底是哪个对象的m_B
		cout << " static void func调用 " << endl;
	}

	static int m_A;    //静态成员变量
	int m_B;

	//静态成员函数也是有访问权限的
private:
	static void func2()
	{
		cout << " static void func2调用 " << 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;
}

注意：静态成员函数也是有访问权限的

成员变量和成员函数分开储存

#include <iostream>
using namespace std;

// 在C++中，类内的成员变量和成员函数分开储存
// 只有非静态成员变量才属于类的对象上

class Person
{

	int m_A;      //非静态成员变量    属于类的对象上
	
	static int m_B;    //  静态变量类内声明， 类外初始化     不属于类的对象上

	void func() {}   // 非静态成员函数  不属于类的对象上
	
	static void func2() {}    // 静态成员函数  不属于类的对象上
};

int Person::m_B = 0;

void test01()
{
	Person p;
	// 空对象占用内存空间为 1
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	cout << " size of p = " << sizeof(p) << endl;
}

void test02()
{
	Person p;
	cout << " size of p = " << sizeof(p) << endl;
}


int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

下面是运行过程中的效果图