1、面向对象的程序设计有四大特点，它们是抽象、封装、(      )、(      )。
2、类中的成员使用特定的关键字指定不同的访问特性，其中（      ）成员是提供给外部的接口，在类中和类外可见。
3、protected成员的访问权限：派生类(      )访问protected成员，派生类对象(      )访问protected成员，本类的对象(      )访问protected成员（填：能与不能）。
4、C++语言中类成员的访问权限包括private、(      )和(      )。
5、对一个类中的数据成员的初始化可以通过构造函数中的(      )实现，也可以通过构造函数中的(      )实现。
6、假定AB为一个类，则执行“AB  a[10];”语句时，系统自动调用该类的构造函数的次数为(      )。
7、假定用户没有给一个名为AB的类定义构造函数，则系统为其隐含定义的构造函数为(      )。
8、若类X中没有定义拷贝构造函数，则系统为类X定义的默认拷贝构造函数的原型为(      )。
9、类中的成员只能为该类的成员函数及该类的派生类中的成员函数访问，则应加上访问属性（      ）。
10、假设一个类对象数组为a[m]，其中m为常变量，当离开它的作用域时，系统自动调用该类析构函数的次数为（      ）。
11、设p为指向一个动态对象的指针变量，则执行delete p语句时，将自动调用该类的（      ）。
12、在一个类中定义了全部是默认参数的构造函数后，不能再定义（      ）构造函数。
13、假设有一个Test类，则执行“Test a(5),b[2],*p;”语句时，自动调用该类构造函数的次数为（    ）。
14、若将类A的成员函数“void fun();”定义为一个类B的友元函数，则应在类B的定义中加一条语句：（    ）。
15、当一个对象作用域结束时，系统自动调用（    ）函数来释放存储空间。
16、对于类中定义的成员，其默认访问权限为（    ）。
17、每个对象都有一个指向自身的指针，称为（    ）指针，通过使用它来确定其自身的地址。
18、一个类有（    ）个析构函数。
19、在类内定义的（    ）数据不能被不属于该类的成员函数存取。
20、this指针是一个隐含的指针，它隐含于每个类的（    ）中。
1、    #include <iostream.h>
class Date
{
public:
        void set(int y, int m, int d);
void print();
private:
int year, month, day;
};
void Date::set(int y, int m, int d)
{
year = y;
month = m;
day = d;
}
void Date::print()
{
cout<<year<<"."<<month<<"."<<day<<endl;
}
void main()
{
        Date t1;
        t1.set(2005,3,3);
t1.print();
}
2、  #include <iostream.h>
class Date
{
public:
        Date ();
    Date (int y, int m, int d);
    void print();
private:
        int year, month, day;
};
Date:: Date ():year(2005),month(3),day(15)
{   
}
Date:: Date (int y, int m, int d):year(y),month(m),day(d)
{
}
void Date::print()
{
        cout<<year<<"."<<month<<"."<<day<<endl;
}
void main()
{    Date t1,t2(2005,3,18) ;
        t1.print();
        t2.print();
}
3、    # include<iostream.h>
class A
{
public:
      int f1();
      int f2();
      void setx(int m) {x=m; cout<<x<<endl;}
      void sety(int n ) {y= n; cout<<y<<endl;}
      int getx() {return x;}
      int gety() {return y;}
  private:
        int x, y;
};
int A::f1() {return x+y;}
int A::f2() {return x-y;}
void main()
{    A a;
a.setx(10); a.sety(5);
    cout<&()<<’\t’<<gety()<<endl;
    cout<<a.f1()<<’\t’<<a.f2()<<endl;
}
4、    # include<iostream.h>
class T
{
public:
        T(int x, int y)
    {
a=x; b=y;
              cout<<”diao yong gou zao han shu 1.”<<endl;
              cout<<a<<’\t’<<b<<endl;
      }
      T(T &d)
      {
cout<<”diao yong gou zao han shu 2.”<<endl;
              cout<< d.a<<’\t’<<d.b<<endl;
        }
      ~T() {cout<<”diao yong xi gou han shu.”<<endl;}
      int add(int x,int y=10) {return x+y;}
private:
        int a,b;
};
void main()
    {
T d1(4,8);
          T d2(d1);
          cout<<d2.add(10)<<endl;
    }
5、#include<iostream.h>
class K
{
public:
        int x;
        K (int i){x=i;}
        void fun1(int j){x+=j;cout<<"fun1:"<<x<<endl;}
        void fun2(int j){x+=j;cout<<"fun2:"<<x<<endl;}
};
void main()
{
        K c1(3),c2(6);
析构函数的定义
        void(K::*pfun)(int)=K::fun1;
(c1.*pfun)(6);
        pfun=K::fun2;
        (c2.*pfun)(12);
}
1、继承，多态                      2、公用
3、能，不能，不能                  4、protected，public
5、初始化表，函数体                6、10
7、缺省的构造函数                  8、X::X(X &x);
9、protected                      10、m
11、析构函数                      12、重载
13、3                            14、friend void A::fun();
15、析构                          16、private
17、this                          18、1
19、private和protected            20、非静态成员函数
1、2005.3.3                        2、2005.3.15
2005.3.18
3、10
5
10        5
15        5
4、调用构造函数1.
4              8
调用构造函数2.

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。