C++基础篇（4）——类与对象

引言：

               问：知道在C++中，声明和定义的区别吗？

概述：

              本篇博客主要内容有：1 类和实例化 2 C++俩大基本成员函数：构造函数以及析构函数；3类和对象的性质。

内容：

               一 类及其实例化

            1 定义类：

               （1）声明类：   类是对一组性质相同对象的程序描述。

                        class 类名{

                            private：

                                私有数据和函数

                            public：

                                公有数据和函数

                            protected：

                                保护数据和函数

                        }  

              （2）定义成员函数：类中声明的成员函数用来对数据成员进行操作，还必须在程序中实现这些成员函数。

                        返回类型 类名::成员函数名（参数列表）

                        {

                                成员函数的函数体//内部实现

                        }

              （3）数据成员的赋值

                    赋值和初始化是俩个概念，赋初值是在有了对象A之后，对象A调用自己的成员函数实现赋值操作；初始化是使用与类同名的构造函数实现的。

               （4）规定：1）类要先声明后使用

                                  2）类是具有惟一标识符的实体

                                  3）在类中声明的任何成员不能使用extern、auto和register关键字进行修饰。

                                  4）类中声明的变量属于该类，某些情况下，变量也可以被该类的不同实例所共享。

            2 使用类的对象：

                （1） 若定义的是类对象指针，定义方式：类名* 对象指针名；对象指针名=对象的地址；也可以 类名* 对象指针名=对象的地址；

                （2） 注意是，访问对象成员区别与应用，对象指针名 ->对象成员名；对象别名.对象成员名。

             3 数据封装：C++对其对象的数据成员和成员函数的访问是通过访问控制权限来限制的。   

           二    俩大基本成员函数

          构造函数      

            1 默认构造函数：C++编译器在没有定义构造函数的情况下，自动建立一个不带参数的构造函数。

                （1）作用：类没有自定义构造函数，却可以使用该类直接产生对象。

               （2）使用：若类中无自定义函数，可以不写出不带参数的与类同名的构造函数，交给编译器自动提供；若类中定义了带参数的构造函数，但是又用到默认构造函数初始化对象，就必须写出一个不带参数的与类同名的函数，否则会造成编译错误。

             2 自定义构造函数：

                 （1）自定义的构造函数，就是用户自己定义的处理数据的功能函数。

                （2）自定义构造函数的名字应该与类名相同，并在定义构造函数时不能指定返回类型，即使是void类型也不可以。

                （3）俩种定义方式：1）类体内声明定义

                                                               class Point

                                                                {

                                                                    private：

                                                                        int x;

                                                                     public : 

                                                                        Point();

                                                                        Point(int a){

                                                                            x = a;

                                                                        }

                                                                }

                                                           2）类体内声明，类体外定义

                                                                class Point

                                                                {

                                                                    private：

                                                                        int x;

                                                                     public : 

                                                                        Point();

                                                                        Point(int a);

                                                                }

                                                                Point::Point():x(0){};

                                                                Point::Point(int a) : x(a){

                                                                    cout<<"输入值" <<a<<","<<b<<endl;

                                                                }

                   （4）注意：1）不能在程序中显式的调用构造函数，构造函数自动调用，例如：构造一个Point类的对象a，不能写成"Point  a.Point(x,y)"，只能写成Point a(x,y)；产生对象后，也不能调用 a.Point(x,y)改变对象的属性值，可以通过对象调用成员函数的形式来改变对象数据成员的值。

                                    2）如果程序定义了自己的有参数构造函数，又想使用无参数形式的构造函数，可以将相应的构造函数全部使用默认参数设计。例如：在Point中定义构造函数 public : Point(int = 0,int = 0);                                                
             3 复制构造函数：

                （1）用处：使用已有的对象来建立一个新对象。

                  （2）函数原型：A::A(const A &)或A::A(A &)。

                  （3）定义：A::A(Point& b){ x=b;}

                  （4） 注意：复制构造函数必须使用对象的引用作为形式参数，推荐使用A::A(const A &)
             析构函数：           

            1 定义析构函数：

                （1）类中声明：~Point();

               （2）类外定义：Point::~Point(){ Point *ptr = new Point[2];  delete []ptr;}

                （3）注意事项：1）定义析构函数时，不能指定任何返回类型，即使指定void返回类型也不行。

                                                2）析构函数也不能指定参数，但是可以显式地说明参数为void，即形如A::~A(void)。

                                              3）一个类也只能定义一个析构函数且不能指明参数，以便编译系统自动调用。

                                              4）析构函数在对象的生存期结束时被自动调用。

                                         5）全局对象和静态对象的析构函数在程序运行结束之前调用。

                                              6）类的对象数组的每个元素调用一次析构函数，全局对象数组的析构函数在程序结束之前被调用。

                                              7）若定义的时候没有定义析构函数，编译器为它产生一个函数体为空的默认析构函数。

             2 delete运算符：若不使用delete调用析构函数，系统按后建先析构的原则析构对象，否则按delete的顺序析构。

           类和对象的性质：         

            1 对象的性质：

              （1）同一类的对象之间可以相互赋值：因为类本身也是一种数据类型，对象是类的实例，也就是一种数据类型，例如int类型的变量可以相互赋值，所以可知同一类的对象可以相互赋值。

              （2）可使用对象数组；

              （3）可使用指向对象的指针，使用取地址运算符&将一个对象的地址置于该指针中；

                      注意：指向对象的指针不能取数据成员的地址，也不能取成员函数的地址。

              （4）对象可以用作函数参数，例如func1（const B &b）

                      注意：为什么加入const？为了避免被调用函数func1修改原来对象b的数据成员。

              （5）对象作为函数参数时，可以使用对象、对象引用和对象指针；

                      注意：函数重载不能同时采用三种同名函数，因为使用参数为对象和对象引用时，编译系统无法区别这俩个函数，只能选一种。

                （6）一个对象可以用做另一个类的成员。

      2 类的性质：

              （1）类的权限   1）类本身的成员函数可以使用类的所有成员（私有和公有成员）；

                                           2）类的对象只能访问公有成员函数，例如：a.setA（）；

                                           3）其他函数不能使用类的私有成员，也不能使用公有成员函数，只能通过类的对象使用类的公有成员函数。

                                           4）A类包含B类的对象，A类只能通过B类的对象使用B类的成员函数，通过成员函数继而使用B类的数据成员。

              （2）不完全的类声明：class myClass；即没有类体。

                        1）为什么？因为有的类没有完全定义之前就得引用该类，例如引用另一个文件中定义的类。

                        2）注意：不完全声明类不能实例化，否则编译出错；仅用于类和结构，企图存取没有完全声明的类长远，也会引起编译错误。

              （3）空类：主要适用于一些类还没有完全定义或实现时进行先期测试，不然程序无法通过编译。

              （4）类作用域：类声明后，花括号里面的作用域。  

          小插曲：                 

                 this指针是C++实现封装的一种机制，它将对象和该对象调用的成员函数连接在一起。

              一个对象的this指针并不是对象本身的一部分，不会影响sizeof（对象）的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。

总结：

              C++区别于C#以及java，它的构造函数有特殊的用法，例如复制构造函数这样的用法，主要是传引用。主要了解C++类和对象的一些原理和机制，帮助我们深入理解面向对象。

              最后，到了回答大家引言里面的问题了，声明就是在类中给它起了一个名字，告诉编译器你将要使用它，但是编译器不会为它分配内存空间，但是定义就需要编译器为它分配内存空间了，之后就必须要初始化了，有时我们也通过初始化来分别是定义还是声明。

              欢迎大家留言，积极提问题，下一篇博客的引言就会出现你的问题了，我们共同进步，fighting！！！