C++有关类的总结

 

 构造函数 --- 初始化对象
   （1）构造函数名字必须与类名一样
   （2）构造函数不能写返回类型
  
   构造函数在创建对象时，系统自动调用
  
   构造函数允许重载，按用户要求，适应多种情况
   当类中一个构造函数都没有的时候，系统提供默认无参的构造函数
   但如果在类中定义了一个构造函数，系统就不提供默认的了，所以，建议，在写构造函数时，都要写一个无参的构造函数
  
3、对类的安全的定义
   变量 -> 私有 -> private  保护变量，防止外界随意修改，只能在类的内部使用（只能被自己的成员函数使用）
   函数 -> 公有 -> public
  
   为保证私有变量也能为外界访问，在类内部提供set,get方法
   set方法没有返回值，但要求有参数
   get方法肯定有返回值，没有参数
  
4、定义类的步骤
   （1）写属性的行为
          成员变量   函数
   （2）成员变量--> private
         成员函数 --> public
    (3)特殊函数
       构造函数，建议写2个。一个有参数的，一个无参的
       get,set函数，一个成员变量对应一对get,set函数，是外界访问此变量的唯一途径
            对于setXXX函数，没有返回值，有参数，参数的类型与被赋值的属性类型一致。
            对于getXXX函数，没有参数，有返回值，返回值的类型与输出的属性类型一致。
       类的行为

Person per ;  创建了一个对象，系统调用构造函数。
   Person *p = NULL ; 声明一个类的指针，系统是不会调用构造函数的
  
   Person * p = NULL;
   p = new Person ; 在堆中申请一个类空间
   delete p;
   在堆中的数据没有名字，只能通过指针访问类对象，访问类的成员变量：
   (*p).sayHello();
   p->sayHello();
  
   Person ps[5];声明一个Person类型的数组，会调用5次构造函数
                数组在声明的时候，系统会为其分配空间
                并且在声明数组的时候，没有机会指定构造函数，只会调用无参的构造函数

 

 

类继承访问权限问题:

                                       public extends       protected extends       private extends
父类的private属性        不能访问                   不能访问                     不能访问
父类的protected属性    变成protected                 不变                    变成private，子类可以访问，子类的子类不能访问
父类的public属性          不变                     变成protected                变成private，子类可以访问，子类的子类不能访问

 

 

多态
   （1）什么是多态？
        一个int类型的指针，只能指向一个int类型的变量
        对于对象来讲Person类型的指针 ，能指向Person类型的对象
        Person类型的指针能指向一个Teacher（extend Person）类型的对象
       
   （2）多态的特征：
        父类的指针可以指向子类的对象
        通过父类指针只能调用父类中声明的方法
        通过指针调用函数的时候，若函数是个虚函数，表现出来的行为是对象自身的行为
       
        Person *p = new Teacher ;
        编译时类型     运行时类型
       
   （3）子类的指针不能指向父类对象
        因为子类中会有子类特有的函数，运行时不能通过指针调用子类特有的函数
       
   （4）" virtual "父类函数的返回值前加此关键字，则为虚函数
  
   （5）产生多态的必要前提：
        继承，方法覆盖，虚函数

在释放资源的时候
   delete p ;
   只会调用Person类的析构函数，因为指针的类型是Person的，这样会造成子类的空间得不到及时的释放，会造成内存泄露
   把析构函数也写成虚函数，这样就会先调用子类的析构函数，再析构父类的析构函数
  
   在继承关系中，父类的析构函数必须是虚函数！！！   

 

构造函数有很多种，因为没有指定构造函数，就会默认使用无参的构造函数。如果父类没有无参的构造函数，那么就会出现编译错误。
    可以使用这种形式Teacher(char* name, int age, double salary):Person(name,age){......}，指定使用父类的有参构造函数。    

 

抽象类
   只有函数声明，没有函数实现
   纯虚函数：没有实现的函数  virtual void writeLog(char*)=0;
             若不写" =0 "，则系统会认为是函数声明，会试图去别的" .cc "文件中去找函数实现
   含有纯虚函数的类称为抽象类，是抽象数据类型，不能创建对象
   抽象类型就是为了被别人继承的，子类覆盖纯虚函数，提供函数实现
   通过父类规范子类的用法
  
   如果子类没有完全实现抽象父类的所有纯虚函数，则认为子类还是一个抽象数据类型
  
   用到virtual的地方：
   （1）继承
   （2）多继承
   （3）纯虚函数

 

静态数据
   在类中定义一个静态数据  （实际上就是一种全局变量）
   （1）不依赖于对象,在对象不存在之前就已经存在了
   （2）所有对象共享   
  
   与全局变量的区别：
   （1）使用的类中的静态变量，必须通过类名使用
   （2）而且受访问控制符号的限制
   （3）静态变量在类中声明的时候不能赋值，要在类外初始化
        class A{
        public :
            static int a;
        };
        int A::a = 100;  //此时才分配空间

        int main(){
             cout << A::a <<endl;    //静态变量的用法，不依赖对象，直接使用
        }
       
    与成员变量的区别
    （1）成员变量依赖与对象，类对象不存在，成员变量也不存在
         静态变量不依赖于对象，只要有类声明，就存在
    （2）所有对象共享一份静态变量

 

静态函数
   在函数前加static
   不依赖于对象，没有对象依然可以通过类名调用静态函数
   A::fn();
  
   在类声明的时候，静态函数和静态变量就存在了
   静态函数只能使用静态变量，不能使用成员变量

 

   拷贝构造函数

以一个已存在的对象为模版创建一个新对象
  声明方法： Person(const Person & p){...}  //即节省空间，又保证模版不会被修改
  
   默认拷贝构造函数，执行的就是简单的内存拷贝 --- 浅拷贝

   （1）浅拷贝
        只拷贝地址，而不是对指针指向空间的拷贝，会造成2个指针指向同一个空间
   （2）深拷贝
        为指针创建新空间，拷贝指针指向空间的内容
  
   调用拷贝构造函数的时机：    
   （1）在值传递的时候
   （2）A a;        //默认构造函数
        A a1 = a;   //在声明的时候，用一个对象赋值，使用的是拷贝构造函数
   （3）A a1;
        A a2(a1);   //显示的调用拷贝构造函数，传的参数是个对象
       
    什么时候需要自己写拷贝构造函数？
         使用了动态内存，就会面临浅拷贝的现象，需要自己写拷贝构造函数