player.h

#ifndef _PLAYER_H_
#define _PLAYER_H_#include "address.h"
#include 
using namespace std;
class Player{public:Player(){addr = NULL;}Player(int num, string name, int age, double salary){this->num = num;this->name = name;this->age = age;this->salary = salary;this->addr = NULL;}Player(int num, string name, int age, double salary, Address *addr){this->num = num;this->name = name;this->age = age;this->salary = salary;this->addr = addr; }~Player(){}void setNum(int num){this->num = num;}int getNum() const{return num;}  void setAge(int age){this->age = age;}int getAge() const{return age;}void setSalary(double salary){this->salary = salary;}double getSalary() const{return salary;}void setAddress(Address *addr){this->addr = addr;}Address *getAddress(){return addr;}void out(){cout <<"num:  "<out();}cout <<"******************" << endl;}private:int num;string name;int age;double salary;Address *addr;
};#endif

player_test.cpp

#include "address.h"
#include "player.h"
#include using namespace std;int main(void)
{Address addr("china", "shanghai", "shanghai","huaihai RD");Player p1(17, "Lin", 24, 10000, &addr);p1.out();cout <<"-------------------" << endl;Player p2(24, "Kobe", 34, 20000);Address addr2("china", "jiangsu", "kunshan","xuey RD");p2.setAddress(&addr2);p2.out();cout <<"-------------------" << endl;Address *addr3 = new Address("USA", "MAIAMI", "MAIAMI", "MM.RD");Player *p3 = new Player(6, "James", 28, 20000, addr3);p3->out();delete addr3;delete p3;return 0;
} 

13. 友元

类具备封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数能够访问类中的公有成员，但是假如将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。
为了解决上述问题，提出一种使用友元的方案。友元是一种定义在类外部的普通函数，但他需要在类体内进行说明，为了和该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是他能够访问类中的私有成员。友元的作用在于提高程序的运行效率，但是，他破坏了类的封装性和隐藏性，使得非成员函数能够访问类的私有成员。

• 友元包括：友元函数、友元类
  关键字：friend
  友元函数：
  友元函数的特点是能够访问类中的私有成员的非成员函数。友元函数从语法上看，他和普通函数相同，即在定义上和调用上和普通函数相同。
  友元类：
  友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。
  当希望一个类可以存取另一个类的私有成员时，可以将该类声明为另一类的友元类。定义友元类的语句格式如下：
  friend class 类名;
  其中：friend和class是关键字，类名必须是程序中的一个已定义过的类。
  例如，以下语句说明类B是类A的友元类：
  class A
  {
  …
  public:
  friend class B;
  …
  };
  经过以上说明后，类B的所有成员函数都是类A的友元函数，能存取类A的私有成员和保护成员。
• 使用友元类时注意：
  (1) 友元关系不能被继承。
  (2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
  (3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明

注意事项：
1.友元可以访问类的私有成员。
2.只能出现在类定义内部，友元声明可以在类中的任何地方，一般放在类定义的开始或结尾。
3.友元可以是普通的非成员函数，或前面定义的其他类的成员函数，或整个类。
4.类必须将重载函数集中每一个希望设为友元的函数都声明为友元。
5.友元关系不能继承，基类的友元对派生类的成员没有特殊的访问权限。如果基类被授予友元关系，则只有基类具有特殊的访问权限。该基类的派生类不能访问授予友元关系的类。

14. 继承

继承：类与类之间的关系
父类(基类) 子类(派生类) 继承语法
构建子类对象，先调用父类的构造函数，再调用子类自己的构造函数，析构的时候先调用子类自己的析构函数，再调用父类的析构函数
父类中的public和protected的成员变量和成员函数都会被子类继承下来

覆盖：
如果子类中有和父类函数名相同且参数相同的成员函数，则在子类对象调用该成员函数时会把父类的覆盖掉

隐藏：
如果子类中有和父类函数名相同但参数不同的成员函数，
则会在父类中该名称的成员函数会被隐藏掉

父类的指针绑定子类的对象 OK
子类的指针绑定父类的对象 error！

通过对象指针进行的普通成员函数调用，仅仅与指针的类型有关，而与此刻指针正指向什么对象无关。想要实现当指针指向不同对象时执行不同的操作就必须将基类中相应的成员函数定义为虚函数。

inherit.cpp

#include 
#include 
using namespace std;// 派生类是基类的具体化，而基类是派生类的抽象。
// 在多继承时，如果省略继承方式，默认为private
// 如果在派生类中声明了一个与基类成员相同名字的函数，派生类的新成员会覆盖基类的同名成员/* 不管何种继承 基类的私有程序都不能被派生类继承 否则会破坏C++的封装特性* 基类的友元函数也不能被继承，友元只是能访问指定类的私有和保护成员的自定义函数，不是被指定类的成员，自然不能继承* 基类与派生类的静态成员函数与静态成员是共用一段空间的，即静态成员和静态成员函数是可以继承的*/
// public公有继承时 基类的公用成员public和保护成员protected在派生类中保持原有的访问属性，其私有成员仍为基类私有，即在派生类中不能访问，在类外也不能访问
// protected保护继承 特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的
// private私有继承 私有继承即所有基类成员均变成派生类的私有成员，基类的私有成员仍然不能在派生类中访问class BASE
{
public:void who(){cout << "this is base !" << endl;}void Fun(){cout << "this is base Fun ! " << endl;}
};class CD1:public BASE
{
public:void who(){cout << "this is CD1 !" << endl;}
};class CD2:public BASE
{
public:void who(){cout << "this is CD2 !" << endl;}
};int main(int argc, char* argv[])
{CD1 obj1;CD2 obj2;obj1.Fun();obj2.Fun();obj1.who();  //this is CD1 !obj2.who();  //this is CD2 !return 0;
}

15. 虚函数

• 什么是虚函数
  简单地说，就是在成员函数前加关键字virtual，这样这个成员函数就变成了虚函数。
  虚函数允许派生类取代基类所提供的实现。编译器确保当对象为派生类时，派生类的实现总是被调用，即使对象是使用基类指针访问而不是派生类的指针。

在函数形参表后面写上= 0以指定纯虚函数，含有纯虚函数的对象（抽象类）不能被实例化，只能作为基类被继承。

virtual.cpp

#include 
#include 
using namespace std;/**************************
*加virtual与不加virtual的区别
***************************/
class BASE
{
public:void who()  {cout << "this is base !" << endl;}
/*virtual void who()     //virtual{cout << "this is base !" << endl;}
*/
};class CD1:public BASE
{
public:void who(){cout << "this is CD1 !" << endl;}
};class CD2:public BASE
{
public:void who(){cout << "this is CD2 !" << endl;}
};int main(int argc, char* argv[])
{BASE obj;BASE *p;CD1 obj1;CD2 obj2;p = &obj;p->who();p = &obj1;p->who();p = &obj2;p->who();obj1.who();obj2.who();return 0;
}

16. 模板

C++中的一个概念：
泛型编程：所谓泛型编程就是独立于任何特定类型的方式编写代码。模板是泛型编程的基础。

• 模板函数：
  函数模板是生成函数代码的样板，当参数类型确定后，编译时用函数模板生成一个具有确定类型的函数，这个由函数模板而生成的函数称为模板函数。
  模板定义以关键字template开始，后接模板形参表，模板形参表是用尖括号括住的一个或多个模板形参的列表，形参之间以逗号分开。

• inline函数模板：
  函数模板可以用与非模板函数一样的方式声明为inline。说明符放在模板形参表之后、返回类型之前，不能放在关键字template之前。

template  inline T min(const T&, const T&);  //ok
inline template  T min(const T&, const T&);  //error

• 类模板
  由于篇幅有限，关注公众号（Linux兵工厂），后台回复C++获取全部实例代码。

17. 类的大小与成员变量的访问

• 类所占字节大小似于结构体,与成员变量有关

#include 
using namespace std;class A{public:A():m_var1(10),m_var2('a'),m_var3('b'){}~A(){}void disp(){cout <<"m_var1="<