1.类的定义：

class className
{
  //类体：由成员函数和成员变量组成
};//注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class Person
{
 public:
   void ShowInfo()
   { cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;}
private:
   char*_name;
   char*_sex;
   int age;
};

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

Person.h

class Person
{
public:
  void ShowInfo();
 private:
  char*_name;
  char*_sex;
  int age;
};

Person.cpp

#include"Person.h"
void Person::ShowInfo()
{
  cout<<_name<<"-"<<_sex<<"-"<<_age<<endl;
}

2.类的访问限定：

2.1访问限定符：

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

2.2类的作用域：

类定义了一个新的作用域，类的所有成员都属于这个作用域，在类的作用域外要调用其中的成员时，要用：：来指明调用内容的作用域。

比如栈的简单实现和调用：

Stack.h:

#include<iostream>

typedef int DataType;
class Stack
{
public:
	void Init(size_t capacity);
	void Push(DataType data);
	DataType Top();
	void Destroy();
private:
	DataType* _arry;
	int _capacity;
	int _size;
};

Stack.cpp:

#include"Stack.h"

void Stack::Init(size_t capacity)
{
	 _arry = (DataType*)malloc(capacity * sizeof(DataType));
	if (_arry == nullptr)
	{
		perror("malloc failed");
		return;
	}
	_capacity = capacity;
	_size = 0;
}
void Stack::Push(DataType data)
{
	int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
	 _arry = (DataType*)malloc(newcapacity * sizeof(DataType));
	_capacity = newcapacity;
	_arry[_size] = data;
	_size++;
}
DataType Stack::Top()
{
	return _arry[_size-1];
}
void Stack::Destroy()
{
	free(_arry);
	_arry = nullptr;
	_size = 0;
	_capacity = 0;
}

test.cpp:

#include"Stack.h"
using namespace std;

void test1()
{
	Stack s;
	s.Init(5);
	s.Push(1);
	cout << s.Top() << endl;

}

int main()
{
	test1();
}