c++学习之-------嵌套类的

皇上选妃，由太监类里面的成员函数去执行;

#include <iostream>using namespace std;class Emprror{class Enunch                  //由太监这个类里面的成员函数调用，相对与用户来说这个接口隐藏起来;{public:void pickPricess(Emprror &a);//{//cout<<"为黄上调选妃子";//}}e;int m_age;                 //这个是皇上的public:void nafei(){cout<<"我要纳菲\n";Emprror a;e.pickPricess(a);  //应该不属于皇帝的行为}};void Emprror::Enunch::pickPricess(Emprror &a){cout<<"为黄上调选妃子";a.m_age=10;cout<<a.m_age<<endl;}int main(){  Emprror e;  e.nafei();class A{ public:       void func();};class M{int a;int b;//static int s;,不允许定义局部类，两种情况都不行public:void test(){cout<<__func__<<endl;}friend void A::func();};M a;a.test();return 0;}

1.嵌套类的定义

类的定义里面有另外一个类的定义

2.嵌套类存在的定义

是为了隐藏一些重要的接口功能

3.如果外部函数访问嵌套类里面的，那么应该将嵌套类定义为public属性;

外围类::嵌套类::成员或者是成员方法

4.嵌套类函数的定义

函数类型::外围类::嵌套类::函数(形参)

{

   函数体;

}

5.局部类

局部变量：定义在函数体内部的类叫做局部类

6.局部类的注意点:

局部类:（1）定义在函数体内部的类 ,局部类不能在外部使用，只能在函数体内不使用;

             （2）局部类的成员函数实现必须在类的内部完成

             （3）局部类里面的不能定义静态变量（由静态成员变量的初始化，）//静态变量的初始化位置只能在类实现函数中或者是main()函数之前

             （4）局部类里面可以定义静态成员函数（一般操作静态成员变量依赖于静态成员变量，所以其存在的意义不太大）静态成员函数只能操作静态成员变量

             （5）限制太多，一般不会使用;

             （6）局部变量的友元函数？？？如果在main()外面定义一个友元函数将访问不到;定义在里面又会重定义;

                       局部类不能有友元函数，但是可以有友元类或者是友元成员函数，只在最上面声明，也是不行，因为有可能知道某个类，但是不能找到类里面的具体函数实现;

    

全局类：定义在函数体外部的类，

继承：

1.继承的定义：

class 父类

{

};

class 子类名:继承方式 父类名

{

};

2.子类的构造顺序和析构顺序

 先构造父类，再构造子类

先析钩子类，再析构父类

3.子类继承时想要调用父类有参：

想要调用父类的有参构造：初始化列表

子类可以修改父类的变量成员（本身是由父类决定）

4.继承的注意点:

 （1）子类拥有父类的所有成员，但是子类在自己构造函数的初始化类表不能放问父类的成员;（范围大的不能给范围小赋值）

 （2）子类继承父类，如果初始化列表，没有指明怎么构造父类，默认调用无参构造，或者是默认构造函数;

 （3）友元不能继承，老爸的朋友并不是不是你的朋友;

所以平时写的时候，

5.继承的方式

public:公有继承;

protected:保护继承

private:私有继承;

6.继承方式带来的影响

父类protected   子类：public 可以访问

父类private       子类:用接口继承

7.private和protected;

（1）如果没有继承，那么private和protected

和没有什么区别;

（2）如果有继承

父类的成员属性只能决定：

只能决定子类是否能直接访问父类的成员变量

 继承方式&父类的成员属性值只会决定（外部）：

外部函数能否直接访问子类的成员变量，取交集;

8.抽象类的定义

抽象类不能定义对象

9.抽象类存在的意义

只是为了定义子类公共的接口或者是成员函数，

Animal

10.纯虚函数：让普通类成为抽象类

11.抽象类的特点

（1）存在纯虚函数--->虚函数的一个特例;

（2）抽象类不能定义对象  （ 让别人继承）

 （3）纯虚函数不需要实现

12.具体类继承自抽象类，必须要实现抽象类里面的每一个虚函数，子类实现纯虚函数时，virtual可加可不加

纯虚函数-----》抽象类----》接口

13.多重继承

子类继承多个父类

14.构造和析构的顺序

（1）按照继承的顺序进行构造（无论初始化列表）

 （2）成员变量按照声明的顺序进行构造

  （3）构造自己

    

15.

多重继承的模糊性:

当多个父类有相同的成员变量是相同成员函数的时候，子类继承多个父类时，会造成数据的冗余，带来访问的模糊性，模糊性的问题解决：

(1)在子类使用该成员函数时，加上父类的类名

Child c;

c.father::test();

(2)抽象出来一个虚基类，虚基类里面有父类的共同属性特征

(3)虚拟继承只存在多重继承，如果没有了多重继承，虚拟继承就变得没有实际的意义

虚继承可以解决数据的冗余，多个父类中有相同的成员变量或者成员函数;

多重继承：合成宝物中可能使用继承;

16. 虚拟继承 的构造顺序

       （1）虚继承按照继承的顺序构造

    构造顺序与初始化列表没有关系，初始化列表决定调用有参还是无参构造

     （2）废墟继承按照继承的顺序构造，

     （3）成员变量按照声明顺序构造

     （4）构造自己

函数的叫法：

方法;接口;函数;

17。方法的重写

方法重写存在于继承，子类是对父类同名函数，

子类是对父类同名函数的实现；

//（1）子类对象可以赋值

18.重写成立的条件：

（1）继承

（2）函数同名

19. 赋值兼容原则

   （1）子类对象可以赋值给父类的对象

   （2）子类的对象可以赋值给父类的引用

   （3）子类对象的地址可以给父类的指针f赋值

将来使用父类对象，引用，指针去调用方法，只能调用父类里面的方法;

20.虚函数存在的意义

是让父类使用引用或者是指针调用成员方法或者是成员变量，实际上调用的方法是引用或者是指针指向的实际对象里面的方法

21.多态成立的条件

        （1）虚函数（可以纯虚）

        （2）满足赋值兼容原则

        （3）通过父类的指针或者引用去调用子类的子类重写的方法

虚继承：解决数据的数据的冗余，

纯虚函数：让普通类成为抽象类

虚函数为了实现多态的产生;

多态函数成立的条件：

   （1）方法重写：虚函数（可以使虚函数）

   （2）满足赋值条件兼容原则

   （3）通过父类的指针或者引用调用子类重写的方法;

父类指针指向子类对象

父类引用引用子类对象

运算符重载：

考虑问题:在c语言里面怎么进行加减乘除

1。成员函数重载的方式

(1)成员函数重载运算符

(2)友元函数重载运算符

2。成员函数重载运算符

函数类型          opertator运算符（形参列表）

a.operator+(b)<======>a+b

3.友元函数中在运算符

friend 函数类型 operator运算符（形参列表）

operator+(a,b)<======>a+b

4.怎么确定是使用友元函数还是成员函数重载运算符

  （1）当不需要改变操作数的值，优先采用友员

  （2） 当需要改变操作数的值，优先采用成员

 （3）判断左操作数对象所属的类若不能操作，必须采用友元，否则在参考上面的规范

sizeof()是运算符

5算数运算符

+   -    *   /   %

++             

--

#include <iostream>using namespace std;class Student  {int m_score; public:    Student(int score=0):m_score(score){}//    void test();int operator+(Student &s)                //operator标记符{return this->m_score+s.m_score;}Student & operator++()//(int)             //++ 用成员函数{      ++this->m_score;  return *this;}Student  operator++(int)//(int)          //后面价格int{   Student temp=*this;       this->m_score++;   return temp;   //不能返回局部变量的引用}    int getAge(){  return this->m_score;}friend int operator+(Student &s1,Student &s2) ;         //operate标记符      friend ostream& operator<<(ostream &out,const Student &s );    friend istream& operator>>(istream &in,Student &s );    friend bool operator&&(const Student &s1,const Student &s2);friend bool operator!(const Student &s);  friend bool operator==(const Student &s1,const Student &s2);};  ostream& operator<<(ostream &out,const Student &s )      //输出流重载  cout{out<<"score="<<s.m_score<<endl;return out;}istream& operator>>(istream &in,Student &s )           //输入流重载   cin{ cout<<"score"; in>>s.m_score; return in;}int operator+(Student &s1,Student &s2)                  //加号重载   + //operator标记符    {return s1.m_score+s2.m_score;}   bool operator==(const Student &s1,const Student &s2)     //是否想等的引用 ==   {return s1.m_score==s2.m_score;      }      bool operator&&(const Student &s1,const Student &s2)    //&&{return s1.m_score!=0 && s2.m_score!=0;}    bool operator!(const Student &s)                        //!{    return !s.m_score;}int main(){Student s1(1),s2(2);cout<<"s1,s2相与"<<(s1&&s2)<<endl;cout<<"S1,S2是否想等"<<(s1==s2)<<endl;cout<<s1.operator+(s2)<<endl;   //加号重载//cout<<s1+s2<<endl;cout<<operator+(s1,s2)<<endl;  //加号重载//s1+s2;cout<<(++s1).getAge()<<endl;cout<<(s1++).getAge()<<endl;cout<<s1.getAge()<<endl;cout<<s1;//cout.operator<<(s);不能这么调，//cout.operator(s)//operator<<(cout.s)operator<<(cout,s1);Student s;cin>>s;           //输入操作符重载cout<<s;  //输出操作符重载cout<<!s<<endl;  //取反操作符重载return 0;}

ostream out;//创建一个新的输出流

fflush()函数刷新缓冲区

拥有员

那些运算符不能重载

::                    域名符

.                    取成员函数

.*                  成员函数指针调用方法

sizeof()       计算类型所占字节数

.                   点运算符

12。其他成员运算符

new

new()

-->运算符重载

delete [ ] 是运算符重载