this指针是一个隐含于类中的特殊指针，指向对象本身。也就是说对象一旦被创建，this指针也就存在了。
就好比你的名字叫做Teodoro，别人说你的时候用的是Teodoro，但是你说你自己的时候，用的是“我”。
这个“我”，在C++和Java中，是用this来表示的。而在Python和Objective-C（苹果的开发语言）中，则用self来表示。

程序1

#include <iostream>
using namespace std; class Dog { private: string name; public: Dog(string Name) { name = Name; cout << "Constructor method with name!" << endl; } void run() { cout << name << " is running!" << endl; } }; int main() { Dog dog("Wang Cai"); dog.run(); return 0; } 

运行结果：

Constructor method with name!
Wang Cai is running!

分析：
在构造函数里，Name为形参，实参为main()函数中的“Wang Cai”。
通过name = Name赋值后，dog的属性name就有了值“Wang Cai”。
这样在run()函数中，就可以打印出属性name的值出来。

对程序1稍作改动，将构造函数的形参改为name，与类的私有属性name一样

程序2

#include <iostream>
using namespace std; class Dog { private: string name; public: Dog(string name) { name = name; cout << "Constructor method with name!" << endl; } void run() { cout << name << " is running!" << endl; } }; int main() { Dog dog("Wang Cai"); dog.run(); return 0; } 

运行结果：

Constructor method with name!is running!

分析：
类Dog有一个属性为name，其作用域为整个类，相当于这个类的全局变量。
构造函数的形参为name，其作用域为构造函数内部，是一个局部变量。
name = name; 这个语句发生在构造函数内部，因为局部变量会屏蔽全局变量，两个name指的都是形参name。所以这个语句就相当于形参name给自己赋值。这样类的属性name没有被赋值，一直为空。
在执行dog.run()时 ，因为name为空，所以打印出来的就是空值。

如果构造函数的参数名称与类的属性名称一样，可以显示调用this来加以区分

程序3

#include <iostream>
using namespace std; class Dog { private: string name; public: Dog(string name) { this->name = name; printf("%p\n", &this->name); printf("%p\n", &name); cout << "Constructor method with name!" << endl; } void run() { cout << name << " is running!" << endl; printf("%p\n", &name); } }; int main() { Dog dog("Wang Cai"); dog.run(); return 0; } 

运行结果：

000000000022fe20
000000000022fe30
Constructor method with name!
Wang Cai is running! 000000000022fe20 

分析：
构造函数里的语句为this->name = name; 从打印的内存地址就可以看出，this->name与name不是同一回事。
等号左边的this->name为对象的属性，等号右边的name则为构造函数的形参，具体由main()函数中的实参“Wang Cai”赋值。
这个语句的效果为this-> name = name = “Wang Cai”

执行run()时，这个name肯定只能是类的属性了，而不可能是构造函数的形参。这从打印出来的内存地址可以看出来。
实际上，run()中的name完全等价于this->name，只是this不用显示写出来罢了。当然要显示写出来也是可以的。

最后，看一个更简单的例子。

程序4

#include <iostream>
using namespace std; class A { public: A() { printf("Memory address of this: %p\n", this); } }; int main() { A a; printf("Memory address of a: %p\n", &a); return 0; } 

运行结果：

Memory address of this: 000000000022fe4f
Memory address of a: 000000000022fe4f 

分析：
从运行结果可以看出，在类外部运行的对象的内存地址，与类内部运行的this的内存地址，完全一样。
这也印证了上面说的，别人口中的Teodoro与Teodoro自己口中的“我”，就是同一个人。

面向对象有三个特征：封装、继承和多态。
本节主要讲解封装。

所有的 C++ 程序都有以下两个基本要素：
函数：这是程序中执行动作的部分，它们被称为函数或方法。
数据：数据是程序的信息，会受到程序函数的影响，也叫属性。

封装是面向对象编程中的把数据和操作数据的函数绑定在一起的一个概念，这样能避免受到外界的干扰和误用，从而确保了安全。

我们已经知道，类包含私有成员（private）、保护成员（protected）和公有成员（public）成员。默认情况下，所有的数据成员和函数成员都是私有的。
为了使类中的成员变成公有的（即程序中的类外部的其他部分也能访问），必须在这些成员前使用 public 关键字进行声明。所有定义在 public 标识符后边的属性或函数可以被程序中所有其他的函数访问。

例子：

#include <iostream>
using namespace std; class Adder{ public: // 构造函数 Adder(int i = 0) { total = i; } // 对外的接口 void addNum(int number) { total += number; } // 对外的接口 int getTotal() { return total; }; private: // 对外隐藏的数据 int total; }; int main( ) { Adder a; a.addNum(10); a.addNum(20); a.addNum(30); cout << "Total is " << a.getTotal() << endl; return 0; } 

运行结果：

Total is 60

上面的类把数字相加，并返回总和。公有成员 addNum 和 getTotal 是对外的接口，用户需要知道它们以便使用类。私有成员 total 是对外隐藏的（即被封装起来），用户不需要了解它，但它又是类能正常工作所必需的。

类的设计策略：
通常而言，要把类的数据成员设计成私有（private），类的函数成员则根据实际需要设计成publice, protected或private。

先编写程序：

#include <iostream>
using namespace std; class Animal { protected: float weight; public: void setWeight(float w) { weight = w; } float getWeight() { return weight; } void breathe() { cout << "breathing..." << endl; } }; class Dog : public Animal { private: int legs; public: void setLegs(int number) { legs = number; } int getLegs() { return legs; } void bark() { cout << "wang! wang!" << endl; } }; int main(int argc, char** argv) { Dog dog; dog.setWeight(12.5); dog.setLegs(4); cout << "The dog's weight is " << dog.getWeight() << "kg" << endl; cout << "The dog has " << dog.getLegs() << " legs" << endl; dog.breathe(); dog.bark(); return 0; } 

运行结果：

The dog’s weight is 12.5kg
The dog has 4 legs
breathing...
wang! wang!

程序分析：
（1）Animal为一个类，Dog为另一个类。
class Dog : public Animal 表示Dog类继承了 Animal类。此时，Animal就成了Dog的基类或父类。Dog就成了Animal的派生类或子类。

（2）体重和呼吸是所有动物的共性，所以weight和breathe()定义在类Animal中。腿和吠不是所有动物的共性，所以legs和bark()定义在了类Dog中。

（3）class Dog : public Animal , 这里的public表示继承方式 。
继承方式有三种：public, protected和private。
① 父类为private的属性和方法，不能被子类继承。
② 父类为protected的成员，若被子类public继承的，仍为子类的protected成员；若被子类protected或private继承的，变为子类的private成员。
③ 父类为public的成员，若被子类public继承的，仍为子类的public成员；若被子类protected继承的，变为子类的protected成员；若被子类private继承的，变为子类的private成员。

注：这些不用强记，编多了自然就知道

（4）根据（3）中第③条的结论，若程序改为class Dog : protected Animal，则程序无法通过编译。因为setWeight()和getWeight()被protected继承后，变为Dog的protected成员，而protected成员，无法在类外部（比如main函数中）访问。

构造函数的默认参数

#include <iostream>
using namespace std; class Rectangle { private: int width; int height; public: Rectangle(int w = 0, int h = 0) { cout << "Constructor method is invoked!" << endl; width = w; height = h; } int area() { return width * height; } }; int main(int argc, char** argv) { Rectangle rec1; cout << "Area of rec1 is : " << rec1.area() << endl; Rectangle rec2(5); cout << "Area of rec2 is : " << rec2.area() << endl; Rectangle rec3(5, 10); cout << "Area of rec3 is : " << rec3.area() << endl; return 0; } 

Constructor method is invoked!
Area of rec1 is : 0
Constructor method is invoked! Area of rec2 is : 0 Constructor method is invoked! Area of rec3 is : 50 

#include <iostream>
using namespace std; class Shape { public: Shape() { cout << "Shape's constructor method is invoked!\n"; } }; class Rectangle : public Shape { public: Rectangle() : Shape() { cout << "Rectangle's constructor method is invoked!\n" << endl; } }; int main(int argc, char** argv) { Rectangle rec; return 0; } 

Shape's constructor method is invoked!
Rectangle's constructor method is invoked!

#include <iostream>
using namespace std; class Shape { public: Shape() { cout << "Shape's constructor method is invoked!\n"; } }; class Rectangle : public Shape { public: Rectangle() { cout << "Rectangle's constructor method is invoked!\n" << endl; } }; int main(int argc, char** argv) { Rectangle rec; return 0; } 

Shape's constructor method is invoked!
Rectangle's constructor method is invoked!

#include <iostream>
using namespace std; class A { public: void play() { cout << "playing..." << endl; } }; int main() { A a; a.play(); A *p = &a; (*p).play(); p->play(); return 0; } 

playing...
playing...
playing...

(*指针).方法()        （1）
指针-->方法()         （2）