【自用22.】C++类的静态数据成员以及静态成员函数

需要获取总的人数，如何实现？

方案一：

使用全局变量，在构造函数中对这个全局变量进行修改

具体代码如下：

在Human.cpp中定义全局变量，并在构造函数中对人数进行增加操作

#include "Human.h"
#include <iostream>

using namespace std;

int HumanCount = 0;

Human::Human() {
	name = "无名氏";
	age = 18;
	salary = 30000;
	HumanCount++;
}

Human::Human(int age, int salary) {
	cout << "调用自定义的构造函数" << endl;
	this->age = age;      //this是一个特殊的指针，指向这个对象本身
	this->salary = salary;
	name = "无名";

	addr = new char[64];
	strcpy_s(addr, 64, "China");
	HumanCount++;
}

int Human::getAge() {
	return age;
}

Human* Human::compare1(Human* other) {
	if (age > other->age) {
		return  this; //没有创建新的对象
	}
	else {
		return other;
	}
}

 在Human.h文件中使用extern表示全局变量在其他文件中定义

#pragma once

#include <string>

using namespace std;

extern int HumanCount;

class Human {
public:
	Human();
	Human(int age, int salary);

	int getAge();
	Human* compare1(Human* other);

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char* addr;
};

在main.cpp文件中调用测试

#include <iostream>
#include <Windows.h>

#include <string.h>
#include "Human.h"

using namespace std;

void test0() {
	Human temp1;
	Human temp2;
}

int main(void) {
	Human h1(25, 30000);
	Human h2(18, 8000);

	Human* p;
	p = &h1;

	cout << p->compare1(&h2)->getAge() << endl;

	test0();

	cout << HumanCount << endl;

	system("pause");
	return 0;
}

结果如下

方案二-类的静态数据成员：

 类内静态变量

首先要在Human.h头文件中定义一个静态变量，代码如下：

#pragma once

#include <string>

using namespace std;

extern int HumanCount;

class Human {
public:
	Human();
	Human(int age, int salary);

	int getAge();
	Human* compare1(Human* other);

private:
	string name = "Unknown";
	int age = 28;
	int salary;
	char* addr;
	
	static int humanCount;
};

然后在Human.cpp文件中对这个静态变量进行初始化，初始化的代码如下：

int Human::humanCount = 0;

这里需要注意的是，在类内声明时，需要写static，但是在初始化的时候是不需要写static的。

之后的处理方式与方案一类似，也是在类的成员函数中进行++操作。

然后为了访问到这个静态变量，我们需要定义一个成员函数来进行访问，成员函数的声明如下：

int gethumanCount();

此声明放在Human.h文件的类定义的public部分中

然后在Human.cpp文件中对这个成员函数进行实现，代码如下

int Human::gethumanCount() {
	return humanCount;
}

然后我们在main函数中任意调用一个对象的humanCount数目即可，具体代码如下：

#include <iostream>
#include <Windows.h>

#include <string.h>
#include "Human.h"

using namespace std;

void test0() {
	Human temp1;
	Human temp2;
}

int main(void) {
	Human h1(25, 30000);
	Human h2(18, 8000);

	Human* p;
	p = &h1;

	cout << p->compare1(&h2)->getAge() << endl;

	test0();

	cout <<"HumanCount" << HumanCount << endl;
	cout << "humanCount" << h1.gethumanCount() << endl;

	system("pause");
	return 0;
}

使用结果如下

类的普通成员函数，可以直接访问静态成员（可读可写） 

 但是方案二有一个问题：如果在一个函数中并不需要创建对象，但是需要使用到静态成员变量，则无法在没有对象的情况之下直接调用静态成员变量。

那这个问题需要如何解决呢？

就是接下来要讲到的

类的静态成员函数

要解决上面的问题，我们只需要在刚刚定义的成员函数前面加上static的修饰，如下：

static int gethumanCount();

 这样我们就可以直接使用类名来调用这个成员函数，因为被static修饰的成员函数不属于任何一个对象，而是直接属于这个类。当然也可以通过对象来调用这个成员函数。具体代码如下：

#include <iostream>
#include <Windows.h>

#include <string.h>
#include "Human.h"

using namespace std;

void test0() {
	Human temp1;
	Human temp2;
}

int main(void) {
	Human h1(25, 30000);
	Human h2(18, 8000);

	Human* p;
	p = &h1;

	//cout << p->compare1(&h2)->getAge() << endl;

	test0();

	cout <<"HumanCount" << HumanCount << endl;
	cout << "humanCount" << h1.gethumanCount() << endl;
	cout << "humanCount" << Human::gethumanCount() << endl;

	system("pause");
	return 0;
}

使用后结果如下：

 总结

1. 静态数据成员

对象的成员函数（没有static的成员函数）内部，可以直接访问“静态数据成员”

类的静态成员函数（有static的成员函数）内部，可以直接访问“静态数据成员”

即：所有的成员函数，都可以访问静态数据成员。

类不能直接访问普通的静态数据成员（Human::humanCount 非法）

2. 静态成员函数

对象可以直接访问静态成员函数

类可以直接访问静态成员函数（Human::getHumanCount()）

在类的静态成员函数（类的静态方法）内部，不能直接访问this指针和对象的数据成员！

在类的静态成员函数（类的静态方法）内部，只能访问类的数据成员