1、类和对象
声明类使用关键字class，并在他后面依次包含类名、一组放在{ }内的成员属性和方法以及结尾的分号。

class Human
{
    //Data attributes:
    string Name;
    string Gender;
    //Methods:
    void Talk(string TextToTalk);
    void IntroduceYouself( );
    ……
} ;

就像int分配动态内存一样，也可以使用new为Human对象动态的分配内存;

Human* pAnotherHuman = new Human();  //动态的分配内存
delete pAnotherHuman;

使用句点运算符来访问成员

Human Tom;
Tom.DateBirth="1970";

使用指针运算符（->）访问成员
如果对象是使用new在自有储存区中实例化的，或者有指向对象的指针，则可以使用指针运算符（->）来访问成员属性和方法。

Human* pTom=new Human();
pTom->DataOfBirth="1970";
pTom->IntroduceYouself();
delete pTom;

下面结合代码来看一下：

#include<iostream>
#include<string>
using namespace std;
        class Human
        {
        private:
               string Name;
               int Age;
        public:
               void SetName(string HumansName)
               {
                       Name = HumansName;
               }
               void SetAge(int HumansAge)
               {
                       Age = HumansAge;
               }
               void IntroduceSelf()
               {
                       cout << "I am" + Name << "and am";
                       cout << Age << "years old" << endl;
               }
        };
        int main()
        {
               Human FirstMan;
               FirstMan.SetName("Adam");
               FirstMan.SetAge(30);
               FirstMan.IntroduceSelf();
        }

2、构造函数
构造函数是一种特殊的函数，它与类同名且不返回任何值。因此，Human类在声明内的构造函数声明类似于下面：

class Human
{
 public:
    Human( )
    {
          //代码
    }
}；

在类声明外定义构造函数的代码如下：

class Human
{
public:
    Human( );
 };
 Human :: Human()
 {
    //代码
 }

：：被称为作用域解析运算符。例如：Human::DateOfBirth指的是在Human类中声明的变量DateOfBirth，而::DateOfBirth表示全局作用域中的变量DateOfBirth。
包含初始化列表的构造函数的代码如下：

class Human
{
public:
  Human(string InputName = "Adam" , int Age = 25 )
            : Name(InputName) , Age(InputAge)
  {
        //代码
  }
}；

初始化列表由包含在括号当中的参数声明后面的冒号标识，冒号后面列出了各个成员变量及其初始化值。初始化值可以是参数，也可以是固定的值。
3、析构函数
析构函数在对象销毁时自动被调用。析构函数看起来也像一个与类同名的函数，但前面有一个波浪号（~）。因此，Human类的析构函数声明类似于下面这样,这是在类里面声明：

class Human
{
public:
    ~Human( )
    {
        // code here
    }
};

在类声明外定义析构函数：

class Human
{
public:
    ~Human();
};
Human::~Human()
{
    //code here
}

析构函数与构造函数的作用完全相反。析构函数是重置变量以及释放动态分配的内存和其他资源的理想场所。
析构函数典型代码如下：

#include<iostream>
#include<string>
using namespace std;
class MyString
{
private:
        char* Buffer;
public:
        MyString(const char* InitialInput)
        {
               if (InitialInput != NULL)
               {
                       Buffer = new char[strlen(InitialInput + 1)];
                       strcpy(Buffer, InitialInput);
               }
               else
                       Buffer = NULL;
        }
        ~MyString()
        {
               cout << "Invoking destructor,cleaning up" << endl;
               if (Buffer != NULL)
                       delete[] Buffer;
        }
        int GetLength()
        {
               return strlen(Buffer);
        }
        const char* GetString()
        {
               return Buffer;
        }
};
int main()
{
        MyString SayHello("Hello from string class:");
        cout << "string buffer in MyString is:" << SayHello.GetLength();
        cout << "characters long" << endl;
        cout << "Buffer contains:";
        cout << "Buffer contains:" << SayHello.GetString();
}

程序运行输出为：

string buffer in MyString is:24characters long
Buffer contains:Buffer contains:Hello from string class:Invoking destructor,cleaning up

析构函数不能重载，每个类都只能有一个析构函数。如果你忘记实现一个析构函数，编译器将创造一个伪（dummy）析构函数并调用他。伪析构函数为空，既不释放动态分配的内存。
复制构造函数
浅复制：复制类对象时，将复制其指针成员，都不复制指针指向的缓冲区，造成两个对象指向同一块动态分配的内存，会威胁程序的稳定性。
深复制：所以要将浅复制的参数复制变成地址传递，即按参数引用传递而不是进行二进制复制。代码示例如下

#include<iostream>
#include<string>
using namespace std;
class MyString
{
private:
        char* Buffer;
public:
        MyString(const char* InitialInput)
        {
               cout << "Constructor:creating new String" << endl;
               if (InitialInput != NULL)
               {
                       Buffer = new char[strlen(InitialInput + 1)];
                       strcpy(Buffer, InitialInput);
                       cout << "Buffer points to:0x" << hex;
                       cout << (unsigned int*)Buffer << endl;
               }
               else
                       Buffer = NULL;
        }
        //复制构造函数
        MyString(const MyString& CopySource)
        {
               cout << "copy constructeor:copy from MyString" << endl;
               f (CopySource.Buffer != NULL)
               {
                       Buffer = new char[strlen(CopySource.Buffer) + 1];
                       strcpy(Buffer, CopySource.Buffer);
                       cout << "Buffer points to:0x" << hex;
                       cout << (unsigned int*)Buffer << endl;
               }
               else
                       Buffer = NULL;
        }
        ~MyString()
        {
               cout << "Invoking destructor,cleaning up" << endl;
               if (Buffer != NULL)
                       delete[] Buffer;
        }
        int GetLength()
        {
               return strlen(Buffer);
        }
        const char* GetString()
        {
               return Buffer;
        }
};
void UseMyString(MyString Input)
{
        cout << "Sting Buffer in mystring is" << Input.GetLength();
        cout << "characters long" << endl;
        cout << "Buffer contains:" << Input.GetString() << endl;
        return;
}
int main()
{
        MyString SayHello("Hello from string class:");
        UseMyString(SayHello);
}

程序运行输出：

Constructor:creating new String
Buffer points to:0x004BD5A0
copy constructeor:copy from MyString
Buffer points to:0x004BD5E8
Sting Buffer in mystring is18characters long
Buffer contains:Hello from string class:
Invoking destructor,cleaning up
Invoking destructor,cleaning up

MyString包含原始指针成员char* Buffer，一般不要为类成员声明原始指针，而应该使用std::string。在没有原始指针的情况下，都不需要编写复制构造函数，这是因为编译器添加的默认复制构造函数将调用成员对象（如：std::string）的复制构造函数。