C++之面向对象编程20170912
/******************************************************************************************************************/
一、C++面向对象编程_访问控制和继承
1.继承关系
class Person {
private:
static int cnt;
char *name;
int age;
public:
static int getCount(void);
}
class Student : public Person {
//定义Student类，继承了Person
};
2.访问控制
private 外界不可见，不能直接访问
protected 外界不可见，不能直接访问；子类可以访问
public 外界可以直接访问
3.调整访问权限
派生类内部可以调整继承过来的成员(派生类可见的父类成员)的访问权限，可以提升或降低权限
使用using来实现，例:
class Father {
private:
int money;
protected:
int room_key;
}
class Son : public Father {
private:
int toy;
//using Father::it_skill;
public:
using Father::room_key;//使用using来调整权限为public
}
4.不同继承方式(类型)
主要包括三种继承类型:public ,protected,private//公有继承，保护继承，私有继承
继承产生的权限结果见图
基类private成员派生类不可见(不可见 权限自然不会被改变)
公有继承，基类成员访问权限不变
保护继承，基类成员访问权限全变为protected
私有继承, 基类成员访问权限全变为private
1）．无论哪种继承方式，在派生类内部使用父类时并无差别
2）. 不同的继承方式，会影响这两方面：
外部代码(类外)对派生类的使用(一般是创建对象使用)、
派生类的子类(派生类的子类怎么使用派生类里面的成员)
5.覆写
子类可以覆写从父类继承来的成员函数
6.派生类对象的空间分布
1).
class Student : public Person {
private:
int grade;
void setGrade(int grade) {this->grade = grade;}
int getGrade(void) {return grade;}
public:
void printInfo(void)
{
cout<<"Student ";
Person::printInfo();//调用父类的打印函数
}
};
2).派生类对象内存空间分部
派生类对象内存空间=父类内存空间+自己的独特的属性
//类似在基类内存空间后面追加一份属于派生类自己独特属性的空间
3).(向上)转型
void test_func(Person &p)
{
p.printInfo();
}
int main(int argc, char **argv)
{
Person p("lisi", 16);
Student s;
s.setName("zhangsan");
s.setAge(16);
test_func(p);
test_func(s); /* 等同于 Person &p = (s里面的Person部分);
p引用的是"s里面的Person部分"，所以test_func里使用的是person的printInfo函数*/
s.printInfo();//
return 0;
}
派生类是基类的一种，所以 基类=派生类 时 等同于派生类里面的基类部分赋值给基类
/******************************************************************************************************************/
二、C++面向对象编程_多重继承
1.多重继承
class Sofabed : public Sofa, public Bed {
//不写public默认是私有继承
};
2.多个基类中有相同成员函数的情形
1).可以指定成员函数具体是属于哪个基类的
s.Sofa::setWeight(100);
2).抽出相同的成员形成基类的父类
同时使用虚拟继承，来保证基类共用其父类的同一成员，从而保证派生类使用的是唯一成员(只使用了一个成员，派生类所占内存中只有该成员只占一份空间)
class Sofa : virtual public Furniture
{
};
class Bed : virtual public Furniture
{
};
class Sofabed : public Sofa, public Bed
{
};
int main(int argc, char **argv)
{
Sofabed s;
s.watchTV();
s.sleep();
s.setWeight(100);
return 0;
}
尽量避免使用多重继承，这样会使得程序更加复杂，更容易出错
/******************************************************************************************************************/
三、C++面向对象编程_再论构造函数
1.构造顺序
先父后儿:
1)先调用基类的构造函数，
先虚拟继承的基类后一般继承的基类(相同类型的，先继承哪个就先调用哪个构造函数)
注意，虚拟继承的基类，构造函数只执行一次(虚拟基类中，只使用一份内存，所以只执行一次)
2)自身
先对象成员，后自己的
2.派生类调用基类的有参构造函数
在派生类的有参构造函数中使用:号加上类名(参数)
class LeftRightSofabed : public Sofabed, virtual public LeftRightCom {
private:
Date date;
Type type;
public:
LeftRightSofabed()
{
cout <<"LeftRightSofabed()"<<endl;
}
LeftRightSofabed(char *str1, char *str2, char *str3) : Sofabed(str1), LeftRightCom(str2), date(str3)//派生类的有参构造函数中使用:号加上类名(参数)
{
cout <<"LeftRightSofabed()"<<endl;
}
};
3.类中对象的构造函数的调用
在派生类的有参构造函数中使用:号加上对象名(参数)
class LeftRightSofabed : public Sofabed, virtual public LeftRightCom {
private:
Date date;
Type type;
public:
LeftRightSofabed()
{
cout <<"LeftRightSofabed()"<<endl;
}
LeftRightSofabed(char *str1, char *str2, char *str3) : Sofabed(str1), LeftRightCom(str2), date(str3)
{//派生类的有参构造函数中使用:号加上对象名(参数)
cout <<"LeftRightSofabed()"<<endl;
}
};
/******************************************************************************************************************/
四、C++面向对象编程_多态
1.直接传入
没有转型，实现不了对应的状态，即无法实现多态
class Human
{
public:
void eating(void) { cout<<"use hand to eat"<<endl; }
};
class Englishman : public Human
{
public:
void eating(void) { cout<<"use knife to eat"<<endl; }
};
class Chinese : public Human
{
public:
void eating(void) { cout<<"use chopsticks to eat"<<endl; }
};
void test_eating(Human& h)
{
h.eating();
}
int main(int argc, char **argv)
{
Human h;
Englishman e;
Chinese c;
test_eating(h);
test_eating(e);
test_eating(c);//执行结果全部调用基类的函数，没实现多态
return 0;
}
2.引入虚函数
基类函数名加上virtual表示虚函数，基类对应的函数可以加也可以不加，同时派生类对应的函数可以加也可以不加，已经是虚函数的属性了，此时在向上转型中派生类实现的与基类一样的函数就可以被调用(一般来说也就是实现了覆写)，否则在向上转型中调用的都是基类的(即没有加virtual的情况)。
因此，析构函数要加上virtual，加上后在向上转型中，即基类指针指向派生类的对象时（多态性），如果删除该转换后的基类指针；就会调用该指针指向的派生类析构函数(因为是虚函数)，而派生类的析构函数又自动调用基类的析构函数，这样整个派生类的对象完全被释放。如果析构函数不被声明成虚函数，则编译器实施静态绑定，在删除转换后的基类指针时，只会调用基类的析构函数而不调用派生类析构函数，这样就会造成派生类对象析构不完全。
注意，派生类的对象当然可以调用自己的成员函数不管是否有virtual。
向上转型：子对象转换为父对象(基类指针可以指向派生类的对象)，转换时，如果代码中有执行基类没有的成员函数，则编译就会报错，所以是安全的。
class Human
{
private:
int a;
public:
virtual void eating(void)
{
cout<<"use hand to eat"<<endl;
}
};
class Englishman : public Human
{
public:
void eating(void) { cout<<"use knife to eat"<<endl; }
};
class Chinese : public Human
{
public:
void eating(void) { cout<<"use chopsticks to eat"<<endl; }
};
void test_eating(Human& h)
{
h.eating();
}
int main(int argc, char **argv)
{
Human h;
Englishman e;
Chinese c;
test_eating(h);
test_eating(e);//执行结果调用派生类的函数，实现多态
test_eating(c);//执行结果调用派生类的函数，实现多态
return 0;
}
内部实现机制
静态联编：非虚函数，在编译时就确定了调用哪一个
动态联编：
1).类里面有虚函数，则其对象里有指针，指向虚函数表，子类对象里由于继承也有这个指针，指向虚函数表
2).调用函数的时候，找到指针指向的虚函数表，然后调用里面的虚函数
所以使用虚函数时，对象占用的空间会变大
见下图:
3.虚函数注意事项
1).函数参数使用对象的指针或者引用，才有多态
传值时，无多态(强制转换为基类类型，只剩下基类部分，就没有指针了，静态联编，调用的就只能是基类了)
2).只有类的成员函数才能声明为虚函数
3).静态成员不能是虚函数
4).内联函数不能是虚函数
5).构造函数不能是虚函数
6).析构函数一般都声明为虚函数
这样才可以先释放派生类的(调用自己的清理函数)，再调用基类的析构(清理)函数，而不是只释放基类的
class Human
{
private:
int a;
public:
virtual void eating(void) { cout<<"use hand to eat"<<endl; }
virtual ~Human() { cout<<"~Human()"<<endl; }
};
class Englishman : public Human
{
public:
void eating(void) { cout<<"use knife to eat"<<endl; }
virtual ~Englishman() { cout<<"~Englishman()"<<endl; }
};
class Chinese : public Human
{
public:
void eating(void) { cout<<"use chopsticks to eat"<<endl; }
virtual ~Chinese() { cout<<"~Chinese()"<<endl; }
};
7).重载函数(函数参数不同)，不可以设为虚函数
重载已经是多态了，所以不可以设置为虚函数了。
或者可以理解为，多态是相同的调用方法，可以调用到不同类里面实现的函数，而重载函数参数不同，已经不是相同的调用方法了，所以不能也需要设为虚函数
8).覆写(覆盖)函数(函数参数，返回值都相同)，可以设置为虚函数
9).函数参数都相同，返回值不同时，不可以设置为虚函数，有个例外:
当返回值是本类指针或引用时，可以设置为虚函数
/******************************************************************************************************************/
五、C++面向对象编程_类型转换
1.隐式类型转换：
double d = 100.1;
int i = d; // double转为int
char *str = "123";
int *p = str; // char *转为int *
2.显式类型转换：
兼容c的类型转换，同时具有新的转换特性,
如下的各种转换语句的意思都是把expression转换成type-id类型的对象,
1).reinterpret_cast<type_id>(expression)//重新解析转换 强制类型转换
//是模版函数
//相当于c风格的用小括号()实现的强制类型转换
int *p = reinterpret_cast<int *>(str2); // char *转换为int * ，相当于C风格的()
无法转换const或volatile属性的变量(不能转换只读的为可读可写)，不然会编译报错
2).const_cast<type_id>(expression)//模版函数
用来去除原来类型的const或volatile属性
char *str2 = const_cast<char *>(str); //转换const型变量使用到
int *p = reinterpret_cast<int *>(str2); // char *转换为int * ，相当于C风格的()
3).dynamic_cast<type_id>(expression)//动态类型转换
该运算符把expression转换成type-id类型的对象。
I、Type-id必须是类的指针、类的引用或者void *；
如果type-id是类指针类型，那么expression也必须是一个指针；
如果type-id是一个引用，那么expression也必须是一个引用。
例子：
void test_eating(Human& h)
{//Human& h传进来的由程序来决定的，不能事先确定，这个确定过程是动态的，所以称为动态转换
Englishman *pe;
Chinese *pc;
h.eating();
/* 想分辨这个"人"是英国人还是中国人? */
if (pe = dynamic_cast<Englishman *>(&h))//指针的转换
/*根据指针找到虚函数表找到类信息从而知道对象是否属于某一个类(虚函数表中有类信息以及继承信息)
cout<<"This human is Englishman"<<endl;
if (pc = dynamic_cast<Chinese *>(&h))
cout<<"This human is Chinese"<<endl;
/*根据指针找到虚函数表找到类信息从而知道对象是否属于某一个类，同时虚函数表里面除了类信息还有继承信息，所以也能知道类属于哪个父类*/
}
所以动态类型转换只能用在含有虚函数的类里面，即用于多态的场合
II、动态转换可以转换指针也可以转换引用
如果一个引用不能指向一个实体就没有存在的必要了，引用也不能用来作判断,所以会导致程序崩溃,
所以动态转换经常使用指针而不是引用
III、主要用于类层次间的上行转换(派生类对象转为基类对象)和下行转换(基类对象转为派生类对象)，还可以用于类之间的交叉转换
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全
进行上下行转换是通过虚函数表的类继承信息来判断，转换有可能成功或失败
4).static_cast<type_id>(expression)
//转换在编译时由编译器决定的，转换是事先确定的，所以是静态转换，所以不能转换时编译器会报错
Expression //待转换的对象
type_id //转换后的类型
返回转换后的变量
该运算符把expression转换为type-id类型,
但运行时没有类型检查来保证转换的安全性。
例子：
Human h;
//Englishman e;
//Chinese c;
Guangximan g;
Englishman *pe;
pe = static_cast<Englishman *>(&h);//可以转换但不安全
//Englishman *pe2 = static_cast<Englishman *>(&g);//不能转换
Chinese *pc = static_cast<Chinese *>(&g);//可以转换
使用场景：
I、用于类层次结构中基类和子类之间指针或引用的转换。
II、进行上行转换（把子类的指针或引用转换成基类表示）是安全的(转换时，如果代码中有执行基类没有的成员函数，则编译就会报错，所以是安全的)；
III、进行下行转换（把基类指针或引用转换成子类指针或引用）时，由于没有动态类型检查，所以是不安全的。
IV、用于基本数据类型之间的转换，如把int转换成char，把int转换成enum：这种转换的安全性也要开发人员来保证。
V、把void指针转换成目标类型的指针(不安全!!)
VI、把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
