小白学习C++——类

面向对象（object oriented）程序设计，这是一种非常流行的编程思想，这里会涉及到类的思想。

什么是类？

简单地说，类是一种将数据和函数组织在一起的方式。

举例

假设在一个游戏中，我们想要表示玩家的位置、速度等。我们当然可以为这些数据创建变量：

#include<iostream>
#define LOG(x)  std::cout << x << std::endl

int main()
{
	int PlayerX0, int PlayerY0;
	int PlayerSpeed0 = 2;

	int PlayerX1, int PlayerY1;
	int PlayerSpeed1 = 2;
	std::cin.get();
}

假设有两个玩家，我们可以分别为这两个玩家定义不同的变量来表示。假设变量很多，我们需要定义很长一串的代码来表示这些变量。当然我们可以选择用数组，但实际上这还是一堆无组织的变量充斥在代码中。
现在假如我想要写一个函数来移动这个游戏角色：

void Move(int x, int y, int speed)
{
	...
}

显然要输入三个整数作为函数的参数，这样会产生很对代码，并且难以维持和维护下去。那还有什么别的办法来帮助我们解决这个问题呢？
解决方案就是我们可以为函数创建一个类，叫做player的类，一次性包含所有的数据，并且作为一个新的数据类型。

class player
{
	
};

这个player必须是唯一的，因为这相当于我们创建的一个新的变量类型。类使用花括号括起来，类似于一个函数，但是注意结尾的时候要带上一个分号。括号里面，我们可以定义下面x,y,speed这些变量。这样的话，我们就创建了player这个全新的类，他实际上是一种自制类型。
所以当我们用这个变量类型的时候，也和应用其他的变量类型一样就好了。比如，我们用player这个变量类型新定义一个变量play:

class player
{
	int x,y;
	int speed;
};

int main()
{
	player play;
}

这样我们就创建了一个以player为变量类型的play变量。
由类这个类型制成的变量就叫做对象，新创建对象的过程就叫做实例化。所以我们这里做的就是实例化了一个叫做play的对象。
现在我们要设置这些变量，我们可以用“对象名称.+变量名称”这种形式。即play. x = 5;

class player
{
	int x,y;
	int speed;
};

int main()
{
	player play;
	play.x = 5;
}

但如果我们此时编译的话，会报错，告诉我们play变量中的私有成员不能被访问。这是因为有种东西叫做访问控制，当你设置一个类时，你可以类中属性的可见性。在默认的情况下，类中的成员的访问控制都是私有的——意味着只有类内的函数才能访问者这些变量。但是现在我们希望main函数中也可以访问这些变量，所以在这里我要把这些变量定义为共有的——public，即允许我们在类内访问这些变量。

class player
{
public:
	int x,y;
	int speed;
};

int main()
{
	player play;
}

现在编译之后不会报错，证明我们可以从类外访问这些变量。

到现在为止，我们已经彻底将代码变得整洁，将所有变量收集起来代表play，我们可以很好地进行管理。

类外函数

现在我们有了所有的数据，假如我要用这些数据干点什么应该怎么办呢？比如我想将玩家移动到什么地方——写一个函数来对变量进行操控。
假设现在要写一个移动的函数：

#include<iostream>
#define LOG(x)  std::cout << x << std::endl

class player
{
public:
	int x, y = 1;
	int speed = 1;
};

void move(player& play,int xa,int ya) 
{
	play.x += xa * play.speed;
	play.y += ya * play.speed;
}

int main()
{
	player play;
	std::cout << play.x << std::endl;
	move(play, 1, 1);
	std::cout << play.x << std::endl;
	std::cin.get();
}

定义了一个移动的函数，函数需要三个参数。第一个是我们定义的类类型的变量play，因为这里我们要改变它的值，所以用到引用：“变量类型& 变量”——“player& play”；另外两个参数是两个偏移量xa和ya。函数的body不多描述。
然后在main函数中我们需要调用这个函数，给原始的play数据，加上想移动的距离（这里我想移动的距离是（1,1））即可以实现调用。
运行结果：x变量实现了+1的移动距离。

类内函数

前面提到了类内可以包含函数，这就代表着我们可以将move函数移动到类内，类内的函数称作method（方法）。我们现在把move函数移动到类里面：

#include<iostream>
#define LOG(x)  std::cout << x << std::endl

class player
{
public:
	int x, y = 1;
	int speed = 1;

	void move(player& play, int xa, int ya)
	{
		play.x += xa * play.speed;
		play.y += ya * play.speed;
	}

};

int main()
{
	player play;
	std::cout << play.x << std::endl;
	move(play, 1, 1);
	std::cout << play.x << std::endl;
	std::cin.get();
}

现在我们访问这些变量就不需要再传play了，因为我们现在已经在play类内了，函数中的play.x，play.y，play.speed等变量前面的成员访问符也可以删掉，因为我们已经在类内了，所以函数中的x,y,speed就是指的类内开头定义的那些变量。
在主函数main中的函数调用形式这时候就要发生变化了，因为此时函数是类内定义的函数，所以在调用时需要加上“play.”变为“play.move(1,1);”。这样的形式就会简化很多。

#include<iostream>
#define LOG(x)  std::cout << x << std::endl

class player
{
public:
	int x, y = 1;
	int speed = 1;

	void move(int xa, int ya)
	{
		x += xa * speed;
		y += ya * speed;
	}

};


int main()
{
	player play;
	std::cout << play.x << std::endl;
	play.move(1, 1);
	std::cout << play.x << std::endl;
	std::cin.get();
}

这样的话，假设每个对象都有自己的move函数，当我们为特定的类调用move函数时（例如play.move()）就是调用它自己的move函数，这虽然和类外move函数看起来没什么区别，但是它确实可以让我们的代码看起来简洁不少，当处理大量代码时，这是一个巨大的优势。
所以，本质上讲，类就是使我们能对变量进行组织，变成一个类型，还加了能够操控这些变量的函数，例如上面的play这个类变量的例子：实际上就是在这个类里面定义了三个变量，外加一个操控这三个变量的函数。