面向对象程序设计 类与对象

1、结构化程序设计在规模庞大的时候，会变得难以理解，难以扩充，难以查错，难以重用。

2、面向对象程序设计

（1）将某类客观事物的共同点（属性）归纳出来，形成一个数据结构；

（2）将某类客观事物所能进行的行为也抽象出来，形成一个函数，这些函数可以用来操作

数据结构。

（3）通过某种语法格式，将数据结构和操作该数据结构的函数捆绑在一起，形成一个类。

基本特点：抽象、封装、继承、多态

3、和结构变量一样，对象占用的内存空间的大小，等于所有成员变量的大小之和。

4、每个对象各自有自己的存储空间。一个对象的某个成员变量被改变了，不会影响到另外一个对

象。

5、使用类的成员变量和成员函数：

（1）对象名.成员名

（2）指针---->成员名

          cicle r1; cicle *p; p=&r1; p----->w=5；

（3）引用名.成员名

cicle r1; cicle &p=r1;

6、类的成员函数和定义可以分开写

     类中只写成员函数的原型；

     类外： 类型名 类型：：成员函数名（）{}

7、类成员的可访问范围：

    private:私有成员，只能在成员函数内访问（缺省时，默认私有）

    public:共有成员，可以在任何地方访问

    protected:保护成员

 （1）在类的成员函数内部：

          *当前对象的全部属性、函数；

          *同类的其他对象的全部属性、函数；

（2）在类的成员函数以外的地方，只能访问该类对象的公有成员。

8、成员函数的重载以及参数缺省

 （1）成员函数也可以重载

 （2）成员函数也可以带有缺省的参数

 （3）使用缺省参数时要注意避免有函数重载时的二义性

          void  init(int  val=0){x=val;}

          int  init(){  return x;}

          Lcoation   A；  A.init();//错误，编译器无法盘算调用哪个init

9、构造函数

      （1）成员函数的一种

              *函数名与类名相同，可以有参数，不能有返回值（void也不行）

              *作用是对对象进行初始化，如给成员变量赋初值

              *如果定义类时没有写构造函数，则编译器生成一个默认的无参数的构造函数

                  **默认构造函数无参数，不做任何操作

              *对象所占用的存储空间不是构造函数分配的，它只是在对象已经占有存储空间之后，对

对象进行初始化

              *对象生成时构造函数自动被调用。对象一旦生成，就再也不能执行构造函数。

              *一个类可以有多个构造函数，参数个数或者参数类型不同

        （2）Compex   *arry[3];//这个是指针数组，指针数组可以不进行初始化

                 Compex   arry[3];//这个是对象数组，会进行初始化

10、复制构造函数

        （1）只有一个参数，即对同类对象的引用。

                 形如：X：：X（X  &）或者X：：X（const  X&）二者选一个

                 后者能以常量对象作为参数。

        （2）如果没有定义复制构造函数，那么编译器默认生成复制构造函数

        （3）一个类只有一个复制构造函数，如果自己没有写，编译器自动生成

        （4）不允许有形如X：：（X）的构造函数，必须是引用

        （5）复制函数起作用的三种情况：

                 *当用一个对象去初始化同类的另一个对象时

                 *如果某函数有一个参数是类A的对象，那么该函数被调用时，类A的复制构造函数将被调用

                *如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用

         （6）对象间赋值（=）并不导致复制构造函数被调用

         （7）常量引用参数的使用

                  void  fun(const  Myclass  &obj){函数体}

                  函数中任何试图改变obj值的语句都是非法的

                  只有函数里面的参数是类的对象的时候，才会调用复制构造函数，引用是不会的

11、类型转换构造函数

       目的：实现类型的自动转换

      （1）只有一个参数，而且不是复制构造函数的构造函数，一般就可以看做是转换构造函数。

      （2）当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象（或临时变量）

12、析构函数

     （1）名字与类名相同，在函数名前面加“~”，没有参数返回值，一个类最多只能有一个析构函数

    （2）析构函数在对象消亡的时候自动被调用。

    （3）如果定义类时没有写析构函数，则编译器生成缺省析构函数，缺省的析构函数什么也你做。

    （4）对象数组声明周期结束时，对象数组的每个元素的析构函数也会被调用。

    （5）delete运算导致析构函数调用

             若new一个对象数组，那么delete释放应该写【】。否则只delete一个对象（调用一次析构

函数）

   （6）析构函数在对象作为函数返回值返回后被调用

13、全局对象在main函数之前就会被初始化。

        先构造的后析构。构造函数不进行存储空间分配，析构函数只是负责在对象消亡前进行一些善后工作，不负责释放存储空间，除非里面有delete这种语句。

14、this指针

    （1）指向成员函数所作用的对象

    （2）非静态成员函数中可以直接使用this来代表指向该函数作用的对象指针。

            静态成员函数中不能使用this指针。因为静态成员函数并不具体作用于某个对象。

           因此静态成员函数的真实的参数的个数，就是程序中写出的参数的个数。

15、静态成员变量和静态成员函数

    （1）静态成员：在前面加了static关键字的成员。

    （2）普通成员变量每个对象各自有一份，而静态成员变量一共就一份，为所有对象共享。

    （3）sizeof运算符不会计算静态成员变量。

    （4）普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象

    （5）静态成员不需要通过对象就能访问。

    （6）类名：：成员名   或者  对象名.成员名   或者   指针—>成员名   或者   引用.成员名 

    （7）静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在

    （8）静态成员函数本质上是一个全局函数

    （9）注意C++中，静态变量需要在函数或者类外面进行声明或者初始化，否则编译能通过，

链接不能通过。

    （10）在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

15、成员对象和封闭类

     （1）有成员对象的类叫做封闭类。

     （2）任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。

              具体做法：通过封闭类的构造函数的初始化列表。

             成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，

变量，只要表达式中的函数或者变量有定义就行。 

    （3）封闭类的对象生成时，先执行所有对象成员的构造函数，然后彩之星封闭类的

构造函数。

   （4）对象成员的构造函数调用次序和对象成员在类中说明的次序一致，与他们在成员初始化列表中出现的次序无关。

   （5）当封闭类的对象消亡的时候，先执行封闭类的析构函数，然后再执行成员

对象的析构函数。次序和构造函数调用次序相反。

   （6）封闭类的复制构造函数

16、常量对象

  （1）如果不希望某个对象的值没改变，则定义时可以在前面加const关键字。

17、常量成员函数

  （1）在类的成员函数说明后面加const关键字，则该成员函数称为：常量成员函数。

            void getvalue()  const;

          常量对象不能执行非常量成员函数，可以执行常量成员函数

  （2）常量成员函数在执行期间不应该改修改其所作用的对象。

         因此，在常量成员函数中不能修改成员变量的值（静态成员变量除外），

         也不能调用同类的非常变量成员函数（静态成员函数除外）。

  （3）两个成员函数，名字和参数表都一样，但是一个是const,一个不是，算是重载。

18、常引用

       引用前加const,不能通过常引用，修改其引用的变量。

19、友元

      友元分为友元函数和友元类两种。

   （1）友元函数：一个类的友元函数可以访问该类的私有成员。

           包括两种：一种是普通的全局函数

                             一种是一个类的成员函数

           可以将一个类的成员函数（包括构造、析构函数）说明为另一个类的友元。

   （2）如果A是B的友元类，那么A的成员函数可以访问B的私有成员。

   （3）友元类之间不能传递，不能继承。