首页 > > 程序设计 > C/C++ >

类与对象

2018-06-17 20:58:21来源：未知阅读 ()

1，类是一种用户定义的类型，用于面向对象程序设计，与面向过程程序设计相对。

2，类包含数据成员，成员函数，数组，结构，类等。

3，类的成员分三种:public公有;protected保护段;private私有

私有成员只能在类中可见，不能在类外或者派生类中使用。如果私有成员在第一段，则可以省略private

保护成员在类和派生类中可见

公有成员是类的接口在类中和累外都可见。

4，成员函数在类外定义是，要使用作用区分符:: 返回类型类名::函数名(参数表)

5，可以数组组织对象，例如 Student student[100]；student是一个有一百个类类型元素的数组。

6，访问对象成员，只有公有成员在类外可见，访问运算符是.（类名访问）和-＞（指针访问）

7，this指针，同一个类的每个对象都有自己数据成员的储存空间，但是系统并不会给每一个成员函数都给一个函数副本，也就是说数据有很多套，但是函数只有一套，那么为什么每个对象直接调用类内的数据却是那个对象对应的数据呢，这就是因为创建对象时就会自动建立一个隐藏的指针叫做this，意思是指向这个新创建的对象的数据成员。这是一个隐含常指针，不能显式说明，但可以在成员函数中显式使用。主要在运算符重载，自引用等场合使用。一旦初始化，就获得了对象的地址，指针值就不能再修改和赋值了，以保证不会指向其他对象。

常指针，相当于类名*const this 显式使用 cout＜＜this-＞x＜＜endl

8.类的构造函数和析构函数

当一个用户定义的类类型对象时，建立对象的初始化工作和释放对象资源的工作本来编译程序很轻松就能完成，但是如果比较复杂，那么就要用户自定义构造函数和析构函数。这两个函数都是类里面特殊的成员函数。两者都不能在私有部分定义。

（1）构造函数

构造函数和类名一样，没有返回值类型，可以有参数，构造函数在建立对象时自动调用。

带参数的构造函数可以用指定的数据初始化对象的数据成员。初始化数据成员有两种方法：

class student
｛int aa,bb;
student (int a)｛aa＝a｝   //第一种方法，传入参数进行数据成员的初始化
student(int a, int b)aa(a),bb(b):｛｝//直接在后面用括号来进行初始化
｝

（2）析构函数

析构函数是在类名前面加一个符号~，没有返回值类型，也没有参数，析构函数在类对象作用域结束时自动调用。但如果类对象是由new 创建的动态对象，则必须要用delete来删除动态对象，并这个过程会自动调用析构函数。 ~类名（）{...}

（3）重载构造函数

C++中重载很重要，重载就是一个函数名对应着多个功能不一函数体，然后程序可以根据用户的输入来进行选择用哪一个函数来处理数据。

就如类Date有多个构造函数，创建对象的时候，将根据参数匹配调用其中的一个构造函数。

例如：

class Date
{
    public :
          Date ();  
          Date (int );
          Date (int,int);
          Date (int,int,int);
          ~Date ();
//...
}    
void f()
{
          Date d;                           //调用Date ();
          Date d1(1);                   //调用Date (int );
          Date d2(1,2);                  //调用Date (int,int);
          Date d3(1,2,3);              //调用 Date (int,int,int);
}

但是，如果重载构造函数中有的带默认参数，就会产生二义性

如：

class Date
{
    public :
          Date ();  
          Date (int  10);
          ~Date ();
//...
}    
void f()
{
          Date d（10）;                           //调用Date (int);
　　  Date d1;     //出错，因为产生二义性，程序不知道应该调用哪一个构造函数
}

（4）复制构造函数

在创建对象时，如果想用一个同类型对象的数据对它进行初始化，C++可以完成简单的复制，但是用户自定义的复制构造函数可用于完成更复杂的操作。

复制构造函数要求有一个类类型的引用参数类名：：类名(const 类名&引用名，...);

class a
{
   public:
            a(int A);
            a(const  a&,int A=1 );    //复制构造函数

}

f()
{
       a d(1);                   // 调用a(int A);
       a e(b,0);                  //调用a(const  a&p,int A=1 ); 
       a  f=e;                            //调用a(const  a&,int A=1 ); 
}

调用复制构造函数的时机：创建对象时，调用复制构造函数进行数据初始化；函数具有类类型传值参数或者返回类类型的值时，需要调用复制构造函数。

(5)浅复制和深复制

如果数据成员资源是由指针指示的堆，系统复制对象数据时只进行指针（地址值）的复制，而不会重新分配内存空间。所以这时候就要用户自定义自己的复制构造函数。

9.类的其他成员

（1）常成员

常数据成员： const int M 如果在构造函数中直接用常量进行初始化，那么见了的每个对象的常数据的值都一样；如果用带参数的构造函数来对常数据成员进行初始化，那么就可以建立对象时进行初始化。

常对象：在定义对象时加上前缀 const 则该对象就是常对象。这个对象的所有数据成员在作用于中约束为只读。

常成员函数： class X{ int g() const{};} 它的this 指针类型是 const X *const this. 函数体代码不能修改this指针所指向的对象的成员。

（2）静态成员

静态数据成员：冠以static ,在类中声明，但是要在类外定义。尽管从储存性质上看是全局变量，但是它的作用域是类。在类中声明静态数据成员时和其他数据成员一样都不分配内存，但是建立对象时其他数据成员会分配内存，但是静态数据成员仍然不会分配内存，因为它储存空间的建立并不依赖对象。它在编译时建立内存并进行一次文件范围初始化，如果没有指定初始化值，则自动初始化为0.

静态成员函数：不依赖于类数据结构的共同操作，没有this 指针，静态成员函数只能访问类的静态数据成员。

（3）友元

友元可以是一个普通函数，一个成员函数或者另一个类。友元函数可以访问该类的所有成员。友元关系是非对称，非传递的。

友元函数：

在类A中，将关键字friend 冠于一个函数原型或一个类名前，那么该函数或者那个类就是类A的友元。

class A
{
private:
int i;
friend coid friendfun(A*,int ) ;
};
void friendfun (A*pro, int x)
{
pro->i=x;
};
void main ()
{
A a1;
friendfun(&a1,2);
}

如上面的程序，友元函数必须在参数表显式地指明要访问的对象。

友元类：

class A
{
   friend class B;
   private:
         int x;
}

class B
{
    A aobject;
    
pubic：
void set(int i)
          {
              aobject.x=i;          //直接调用类A的数据成员是合法的 
         }
}

如果数据成员x在类A中是私有，但是在类B中声明的aobject 是公有的，那么在main 函数中就可以访问。B类的成员函数也可以通过参数形式获得A类的对象参数，达到访问A类的目的。

10.类的包含

如果你想编写的一个新的类，里面一些功能需要用到一个已经定义过的类的功能，为了少打一些代码，可以在类里面调用类，这就是类的包含。

class A
{
public:
A(int x):a(x){}
int a;
}

class B
{
int  b;
A aa;
public :
    B(int x,int y):b(x),aa(y){}
//  B（int x,int y）{aa.a=x;b=y}    这样通过赋值的方法b可以赋值，但是不能调用A类的构造函数的，所以这样给aa.a赋值失败，只能像上面那样用括号初始化。
};
void main (0
{
  B objectb (1,2)  ；        //分别把B类里面的b赋值为1，把A类中的a赋值为2
}