标签：

栈与基础类

#if 0
#include<iostream>
using namespace std;
const int MAX=5;     //假定栈中最多保存5个数据

//定义名为stack的类，其具有栈功能
class  stack {
    //数据成员
    float  num[MAX];  //存放栈数据的数组
    int  top;          //指示栈顶位置的变量
public:
    //成员函数
    void init(void) { top=0; }    //初始化函数
    void push(float x)          //入栈函数
    {
        if (top==MAX){
            cout<<"Stack is full !"<<endl;
            return;
        };
        num[top]=x;
        top++;
    }
    float pop(void)          //出栈函数
    {
        top--;
        if (top<0){
        cout<<"Stack is underflow !"<<endl;
        return 0;
        };
        return num[top];
    }
}

//以下是main()函数，用stack类创建栈对象，并使用这些对象
main(void)
{
    //声明变量和对象
    int i;
    float x;
    stack a,b;    //声明(创建)栈对象

    //以下对栈对象初始化
    a.init();
    b.init();

    //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈对象
    for (i=1; i<=MAX; i++)
        a.push(2*i);

    //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示
    for (i=1; i<=MAX; i++)
       cout<<a.pop()<<"  ";
    cout<<endl;

    //以下利用循环和push()成员函数将键盘输入的数据依次入b栈
    cout<<"Please input five numbers."<<endl;
    for (i=1; i<=MAX; i++) {
         cin>>x;
         b.push(x);
    }
 
    //以下利用循环和pop()成员函数依次弹出b栈中的数据并显示
    for (i=1; i<=MAX; i++)
       cout<<b.pop()<<"  ";
}
#endif

构造函数

#if 0
/*构造函数*/
#include<iostream>
using namespace std;
const int MAX=5;   	//假定栈中最多保存5个数据

//定义名为stack的具有栈功能的类
class  stack {
    //数据成员
    float  num[MAX];     //存放栈数据的数组
    int  top;             //指示栈顶位置的变量
public:
    //成员函数
    stack(char c)          //初始化函数-构造函数
    {
        top=0; 
        cout<<"Stack "<<c<<" initialized."<<endl;
    } 	
    void push(float x)      //入栈函数
    {
        if (top==MAX){
            cout<<"Stack is full !"<<endl;
            return;
        };
        num[top]=x;
        top++;
    }
    float pop(void)           //出栈函数
    {
        top--;
        if (top<0){
        cout<<"Stack is underflow !"<<endl;
        return 0;
        };
        return num[top];
    }
}

//以下是main()函数，用stack类创建栈对象，并使用这些对象
main(void)
{
    //声明变量和对象
    int i;
    float x;
    stack a('a'),b('b');    //声明(创建)栈对象并初始化

    //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈
    for (i=1; i<=MAX; i++)
        a.push(2.0*i);

    //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示
    for (i=1; i<=MAX; i++)
       cout<<a.pop()<<"  ";
    cout<<endl;
}
#endif

#if 0
#include<iostream>
using namespace std;
main()
{
    //定义一个名为student的类
    class student {
          int num;
          char *name;
          float grade;
    public:
         //定义构造函数
        student(int n,char *p,float g): num(n),name(p),grade(g){}
        display(void) {
              cout<<num<<" ,"<<name<<","<<grade<<endl;
          }
    }; 

    student a(1001,"XieCh",95),b(1002,"TanXu",96.5);   //创建对象，并初始化
    //student c;  错误，没提供参数

    a.display();            //显示对象a中的数据
    b.display();            //显示对象b中的数据
}
#endif

构造函数重载

#if 0
/*构造函数重载*/
#include <iostream.h>
#include <stdlib.h>
//定义timer类
class timer{
    long minutes;
public:
    //无参数构造函数
    timer(void) { 
        minutes =0;
    };
    //字符指针参数的构造函数
    timer(char *m) { 
        minutes = atoi(m);
    };
    //整数类型的构造函数
    timer(int h, int m) { 
        minutes = 60*h+m ;
    };
    //双精度浮点型构造函数
    timer(double h) { 
        minutes = (int) 60*h ;
    };
    long getminutes(void) { return minutes ; };
};
//main()函数的定义
main(void)
{
    //使用double类型的构造函数创建对象
    timer start(8.30),finish(17.30);
	cout<<"finish(17.30)-start(8.30)=";
    cout<<finish.getminutes()-start.getminutes()<<endl;  

    //使用char指针类型的构造函数创建对象
    timer start0("500"),finish0("800");   //创建对象
	cout<<"finish0(\"800\")-start0(\"500\")=";
    cout<<finish0.getminutes()-start0.getminutes()<<endl;  

    //使用无参数构造函数和整型构造函数创建对象
    timer start1;   
    timer finish1(3,30);  
	cout<<"finish1(3,30)-start1=";
    cout<<finish1.getminutes()-start1.getminutes()<<endl;  

    return 0;
}
#endif

#if 0
#include <iostream>
using namespace std;
//定义rect类
class rect {
    int length;
    int width;
    int area;
public:
    rect(int l=1,int w=1)
    {
        length=l;
        width=w;
        area=length*width;
    }
    void show_rect(char *name)
    { 
		cout<<name<<":"<<endl;
        cout<<"length="<<length<<endl;
        cout<<"width="<<width<<endl;
        cout<<"area="<<area<<endl;
    }
};
//测试使用rect类
void main(void)
{
    //用rect类创建对象
    rect a;
    rect b(2);
    rect c(2,3);

    //调用对象的函数显示对象中的数据
    a.show_rect("a");
    b.show_rect("b(2)");
    c.show_rect("c(2,3)");
}
#endif

析构函数

#if 0
/*析构函数*/
#include<iostream>
using namespace std;
const int MAX=5;   	//假定栈中最多保存5个数据

//定义名为stack的具有栈功能的类
class  stack {
    //数据成员
    double  num[MAX];   //存放栈数据的数组
    int  top;             //指示栈顶位置的变量
public:
    //成员函数
    stack(char *name)  //构造函数
    {
        top=0; 
        cout<<"Stack "<<name<<" initialized."<<endl;
    }
    ~stack(void)   //析构函数
    {
        cout << "Stack destroyed." << endl;  //显示信息
    }

    void push(double x)	//入栈函数
    {
        if (top==MAX)
		{
            cout<<"Stack is full !"<<endl;
            return;
        };
        num[top]=x;
        top++;
    }
    double pop(void) 	//出栈函数
    {
        top--;
        if (top<0)
		{
        cout<<"Stack is underflow !"<<endl;
        return 0;
        };
        return num[top];
    }
}

//以下是main()函数，其用stack类创建栈对象，并使用了这些对象
main(void)
{
    double x;
    //声明(创建)栈对象并初始化
    stack a("a"),b("b");    

    //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈
    for (x=1; x<=MAX; x++)
        a.push(2.0*x);

    //以下利用循环和pop()成员函数依次弹出a栈中的数据并显示
	cout<<"a: ";
    for (int i=1; i<=MAX; i++)
       cout<<a.pop()<<"  ";
    cout<<endl;

    //从键盘上为b栈输入数据,并显示
    for(i=1;i<=MAX;i++) 
	{

        cout<<i<<" b:";
        cin>>x;
        b.push(x);
    }
	cout<<"b: ";
    for(i=1;i<=MAX;i++) 
       cout<<b.pop()<<" ";
    cout<<endl;
}
#endif

类外部定义成员函数

#if 0
/*类外部定义成员函数*/
#include<iostream>
using namespace std;
#define MAX 5
//定义stack类接口
class stack
{
    int num[MAX];
    int top;
public:
     stack(char *name);   //构造函数原型
    ~stack(void);         //析构函数原型
    void push(int n);
    int pop(void);
};
//main()函数测试stack类
main(void)
{
    int i,n;
    //声明对象
    stack a("a"),b("b");    

    //以下利用循环和push()成员函数将2,4,6,8,10依次入a栈
    for (i=1; i<=MAX; i++)
        a.push(2*i);

    //以下利用循环和pop()成员函数依次弹出a栈中的数据，并显示
	cout<<"a: ";
    for (i=1; i<=MAX; i++)
       cout<<a.pop()<<"  ";
    cout<<endl;

    //从键盘上为b栈输入数据,并显示
    for(i=1;i<=MAX;i++) {
        cout<<i<<" b:";
        cin>>n;
        b.push(n);
    }
	cout<<"b: ";
    for(i=1;i<=MAX;i++) 
       cout<<b.pop()<<" ";
    cout<<endl;

    return 0;
}
//-------------------------
//   stack成员函数的定义
//-------------------------
//定义构造函数
stack::stack(char *name)
{
    top=0;
    cout << "Stack "<<name<<" initialized." << endl;
}
//定义析构函数
stack::~stack(void)
{
    cout << "stack destroyed." << endl;  //显示信息
}
//入栈成员函数
void stack::push(int n)
{
    if (top==MAX){
        cout<<"Stack is full !"<<endl;
        return;
    };
    num[top]=n;
    top++;
}
//出栈成员函数
int stack::pop(void)
{
    top--;
    if (top<0){
        cout<<"Stack is underflow !"<<endl;
        return 0;
    };
    return num[top];
}
#endif

public

#if 0
/*public*/
#include<iostream>
using namespace std;
//定义一个全部为public:模式的类
class ex 
{
public:
     int value;
     void set(int n) 
	 { 
         value=n;
     }
     int get(void) 
	 {
        return value;
     }
};
//测试使用ex类
main()
{
    ex a;    //创建对象

    //以下通过成员函数访问对象数据
    a.set(10);
	cout<<"a.get()=";
    cout<<a.get()<<endl;

    //以下直接访问对象的数据成员
    a.value=20; 
	cout<<"a.value=";
    cout<<a.value<<endl;
}
#endif

类接口

#if 0
/*类接口*/
#include <iostream>
using namespace std;
//类接口定义
class ex_class
{
private:
    int iv;
    double dv;
public:
    ex_class(void);
    ex_class(int n,double x);
    void set_ex_class(int n,double x);
    void show_ex_class(char*);
};

//定义ex_class类的构造函数
ex_class::ex_class(void):iv(1), dv(1.0) { }
ex_class::ex_class(int n,double x):iv(n), dv(x) { }

//定义ex_class类的成员函数
void ex_class::set_ex_class(int n,double x)
{
    iv=n;
    dv=x;
}
void ex_class::show_ex_class(char *name)
{
    cout<<name<<": "<<endl;
    cout <<"iv=" <<iv<< endl;
    cout <<"dv=" <<dv<< endl;
}
//使用ex_class类
void main(void)
{
    ex_class obj1;
    obj1.show_ex_class("obj1");
    obj1.set_ex_class(5,5.5);
    obj1.show_ex_class("obj1");

    ex_class obj2(100,3.14);
    obj2.show_ex_class("obj2");
    obj2.set_ex_class(2000,1.732);
    obj2.show_ex_class("obj2");
}
#endif

static

#if 0
/*static*/
#include<iostream>
using namespace std;
//定义一个含有static数据成员的类
class ex
{
    static int num;      //static数据成员
public:
    ex() {num++;}
    ~ex() {num--;}
    disp_count() {
       cout<<"The current instances count:";
       cout<<num<<endl;
    }
};
int ex::num=0;    //设置static数据成员的初值
//main()函数测试ex类
main()
{
    ex a;
    a.disp_count();

    ex *p;
    p=new ex;//分配内存
    p->disp_count();

    ex x[10];
    x[0].disp_count();

    delete p;//释放内存
    a.disp_count();
}
#endif

类作用域符引用成员函数

#if 0
/*类作用域符引用成员函数*/
#include<iostream>
using namespace std;
//定义一个含有static数据成员的类
class ex
{
    static int num;      //static数据成员
public:
    ex() {num++;}
    ~ex() {num--;}
    static disp_count(void) //static成员函数
    {
        cout<<"The current instances count:";
        cout<<num<<endl;
    }
};
int ex::num=0;    //设置static数据成员的初值
//main()函数测试ex类
main()
{
    ex a;
    a.disp_count();

    ex *p;
    p=new ex;
    p->disp_count();

    ex x[10];
	ex::disp_count();   //直接用类作用域符引用静态成员函数

    delete p;
    ex::disp_count();  //直接用类作用域符引用静态成员函数
}
#endif

内联函数

#if 0
/*类的内联函数*/
#include <iostream>
using namespace std;

class ex_class 
{
    int value;
public:
    ex_class(int n) 
	{
        value=n;
        cout << "Stack initialized." << endl;
    }
    ~ex_class() 
	{    
        cout << "The Object destroyed." <<endl;  
    }
    void set_value(int n);
    void show_val(char *name);
} ;

//在类外定义内联成员函数
inline void ex_class::set_value(int n) 
{
    value=n;
}
//在类外定义非内联成员函数
void ex_class::show_val(char *name) 
{
	cout<<name<<": ";
    cout<<value<<endl;
}
//在main()函数中测试ex_class类
main(void)
{
    //创建对象x和y
    ex_class x(10),y(20);

    //显示对象的数据
    x.show_val("x");
    y.show_val("y");

    //设置新值给对象
    x.set_value(1);
    y.set_value(2);

    //显示对象的数据
    x.show_val("x");
    y.show_val("y");

    return 0;
}
#endif

空类

#if 0
/*空类*/
#include <iostream>
using namespace std;
//定义空类empty
class empty
{
};
//在main()函数中用空类创建对象
main()
{
    empty a,*p;  //编译通过
    cout<<"This is a empty class."<<endl;
}
#endif

struct定义类

#if 0
/*struct定义类*/
#include<iostream>
using namespace std;
//用struct关键字定义ex_class类
struct ex_class 
{
    ex_class(int n=1): value(n) {}
    void set_value(int n) 
	{
         value=n;
    }
    show_obj(char *name) {
		cout<<name<<": "<<value<<endl;
    }
private:
    int value;
}
//测试 ex_class类
main()
{
    //用ex_class创建对象
    ex_class a,b(3);
    
    a.show_obj("a");
    b.show_obj("b");

    a.set_value(10);
    b.set_value(20);

    a.show_obj("a");
    b.show_obj("b");
}
#endif

双亲类

#if 0
/*双亲类*/
#include <iostream.h>
#include<string.h>
//定义双亲（parent）类
class parent 
{
    char  f_name[20];
    char  m_name[20];
    char  tel[10];
public:
    // parent类的构造函数，其带有缺省值
    parent(char *p1="",char *p2="",char *p3="") 
	{
        strcpy(f_name,p1);
        strcpy(m_name,p2);
        strcpy(tel,p3);
    }
    //显示parent对象的数据
    show_parent(void) 
	{    
        cout<<"The parent:"<<endl;
        cout<<"    father's name:"<<f_name<<endl;
        cout<<"    mother's name:"<<m_name<<endl;
        cout<<"    tel:"<<tel<<endl;
    }
};
//定义student类
class student 
{
    int       num;
    char      name[20];
    float     grade;
    parent    pt;      
public:
    // student类的构造函数
    student(int n,char *str,float g,class parent t) 
	{
        num=n;
        strcpy(name,str);
        grade=g;
        pt=t;
    }
    //显示student对象的数据
    show_student(void) 
	{
        cout<<"num:"<<num<<endl;
        cout<<"name:"<<name<<endl;
        cout<<"grade:"<<grade<<endl;
        pt.show_parent();
    }
};
//main()函数测试student类的对象
main(void)
{
    //创建双亲对象
    parent p1("Xiej","Yin","83665215");

	//创建学生对象
    student st(10001,"XieCh",91.5,p1); 
	
    //显示学生信息
	cout<<"p1:"<<endl;
	p1.show_parent();

    //显示学生信息
	cout<<"st:"<<endl;
    st.show_student();
}
#endif

重载成员函数

#if 0
/*重载成员函数*/
#include <iostream.h>
#include <stdlib.h>
//定义timer类
class timer{  
    long minutes;
public:
    //定义重载成员函数
    settimer(char *m) 
	{ 
        minutes = atoi(m);
    };
    //定义重载成员函数
    settimer(int h, int m) 
	{ 
        minutes = 60*h+m ;
    };
    //定义重载成员函数
    settimer(double h) 
	{ 
        minutes = (int) 60*h ;
    };
    long getminutes(void) { return minutes; };
};
//main()函数的定义
main(void){
    timer start,finish;   //创建对象

    //使用重载成员函数
    start.settimer(8,30);
    finish.settimer(9,40); 
	cout<<"finish.settimer(9,40)-start.settimer(8,30):";
    cout<<finish.getminutes()-start.getminutes()<<endl;  

    //使用重载成员函数
    start.settimer(2.0);
    finish.settimer("180"); 
	cout<<"finish.settimer(\"180\")-start.settimer(2.0):";
    cout<<finish.getminutes()-start.getminutes()<<endl;  

  return 0;
}
#endif

重载函数

#if 0
/*重载函数*/
#include <iostream>
using namespace std;
//定义复数类
class complex
{
    float  real;       //实部
    float  image;     //虚部
public:
    //重载的运算符"+"的原型
    complex operator+ (complex right);
    //重载赋值运算符"="的定义
    complex operator= (complex right);
    void set_complex(float re, float im);
    void put_complex(char *name);
};
//重载加法运算符"+"的定义
complex complex::operator+ (complex right) 
{
    complex temp;
    temp.real = this->real + right.real;
    temp.image = this->image + right.image;
    return temp;
}
//重载加赋值运算符"="的定义
complex complex::operator= (complex right) 
{   
        this->real = right.real;
        this->image = right.image;
        return *this;
}
//定义set_complex()成员函数
void complex::set_complex(float re, float im) 
{
        real = re;
        image = im;
}
//定义put_complex()成员函数
void complex::put_complex(char *name) 
{
        cout<<name<<": ";
        cout << real << ' ';
        if (image >= 0.0 ) cout << '+';
        cout << image << "i\n";
}
//在main()函数中使用complex类的对象
main(void)
{
    complex A, B, C;  //创建复数对象

    //设置复数变量的值
    A.set_complex(1.2, 0.3);
    B.set_complex(-0.5, -0.8);

    //显示复数数据
    A.put_complex("A");
    B.put_complex("B");

    //赋值运算，显示结果
    C = A;
    C.put_complex("C=A");

    //加法及赋值运算，显示结果
    C = A + B;
    C.put_complex("C=A+B");
    return 0;
}
#endif

友元类

#if 0
/*友元类*/
#include <iostream>
using namespace std;
//定义YourClass类，
class YourClass
{
//指定YourOtherClass是它的友元类
friend class YourOtherClass;  
private:
    int num;
public:
    YourClass(int n){num=n;}
    display(char *YCname){
        cout<<YCname<<".num :";
	    cout<<num<<endl;
    }
};
//定义YourOtherClass，它是YourClass类的友元类
class YourOtherClass
{
public:
    //使用YourClass类的私有成员
    void disp1(YourClass yc,char *YCname){ 
         cout<<YCname<<".num :";
        cout<<yc.num<<endl;   
    }
    //使用YourClass类的公共成员
    void disp2(YourClass yc,char* YCname){
        yc.display(YCname);       
    }
};
//在main()函数中创建和使用YourClass和YourOtherClass类对象
main(void)
{
    //声明YourClass类对象
    YourClass a(20),b(30);

    //显示a和b对象的值
    cout<<"YourClass:"<<endl;
    a.display("a");
    b.display("b");

    //声明YourOtherClass类对象
    YourOtherClass temp;

    //通过temp显示a和b对象的值
    cout<<"YourOtherClass:"<<endl;
    temp.disp1(a,"a");
    temp.disp2(b,"b");
}
#endif

#if 0
#include<iostream>
using namespace std;
//Y类的不完全定义
class Y;

//X类的定义    
class X 
{   
public:
    void disp(Y py,char *name);   //成员函数原型
};

//定义Y类
class Y 
{  
    //声明本类的友元函数
    //X类的disp()为本类的友元函数
    friend void X::disp(Y py,char *name);
     //普通函数putY() 为本类的友元函数
    friend void putY(Y& yc,char *name);         
private: //私有成员
    int num;
    dispY(char *name)
	{    
        cout<<name<<".num="<<num<<endl;
    }
public: //公共成员函数
    Y(int n)
	{  
       num=n;
    }
};

//X类成员函数的实现
void X::disp(Y py,char *name)
{
    cout<<"In X::disp():"<<endl;
    py.dispY(name);   //访问Y类的私有函数
}

//普通函数putY()的定义
void putY(Y& yc,char *name){
    cout<<"In getY:"<<endl;
    yc.dispY(name);
    cout<<name<<".num=";
    cout<<yc.num<<endl;
}

//在main()函数测试X和Y类的功能
main()
{
    //创建Y和X类的对象
    Y y1(10),y2(20);
    X x;

    //不可用Y类对象的私有成员函数显示
    //y1.dispY("y1");
    //y2.dispY("y2");

    //调用X类对象的友元函数显示
    x.disp(y1,"y1");
    x.disp(y2,"y2");

    //用getY函数显示Y类的对象显示
    putY(y1,"y1");
    putY(y2,"y2");
}
#endif

#if 0
/*输入输出运算符重载*/
#include <iostream>
using namespace std;
//定义日期类
class Date    
{
    //定义友元重载输入运算符函数
    friend istream& operator >> (istream& input,Date& dt ); 
    //定义友元重载输出运算符函数
    friend ostream& operator<< (ostream& output,Date& dt ); 
    int mo, da, yr;
public:
    Date(void)
	{  //无参数构造函数
        yr = 0;
        mo = 0; 
        da = 0; 
    }
    Date( int y, int m, int d )   //带参数构造函数
    {
        yr = y;
        mo = m; 
        da = d; 
    }
};
//定义">>"运算符重载函数
istream& operator >> ( istream& input, Date& dt )
{
    cout<<"Year:";
    input>>dt.yr;
    cout<<"Month:";
    input>>dt.mo;
    cout<<"Day:";
    input>>dt.da;
    return input;
}

//定义"<<"运算符重载函数
ostream& operator<< ( ostream& output, Date& dt )
{
   output<< dt.yr << '/' << dt.mo << '/' << dt.da<<endl;
   return output;
}

//在main()函数中测试Date类的插入（<<）和提取（>>）运算符
void main()
{
    //声明对象
    Date dt1(2016,5,4),dt2;

    //显示dt1对象
    cout<<dt1;

    //对dt2对象进行输入和输出
    cin>>dt2;
    cout<<dt2;
}
#endif

#if 0
/*删除对象*/
#include<iostream>
using namespace std;
//定义ex类
class ex_class 
{
    int a;
    double b; 
public:
    ex_class(int n=1,double x=1.0):a(n),b(x) {}
    void show_value(char *name) 
	{
        cout<<name<<" :"<<endl;
        cout<<"a="<<a<<endl;
        cout<<"b="<<b<<endl;
    }
};

//main()函数
main()
{
    //创建ex_class的对象并显示
    ex_class obj1,obj2(10,3.5);    
    obj1.show_value("obj1");
    obj2.show_value("obj2"); 

    //创建ex_class的指针变量
    ex_class *p;

    //p指向obj1并显示
    p=&obj1;
    p->show_value("p->obj1");

    //p指向obj2并显示
    p=&obj2;
    (*p).show_value("(*p)obj2");

    //p指向动态创建的对象并显示
    p=new ex_class;
    p->show_value("p->new");

    delete p;   //删除对象

}
#endif

派生类

#if 0
#include<iostream>
using namespace std;
//基类Box
class Box {
    int width,height;
public:
    void SetWidth(int w) 
	{
        width=w;
    }
    void SetHeight(int h) 
	{
        height=h;
    }
    int GetWidth() {return width;}
    int GetHeight() {return height;}
};
//派生类ColoredBox
class ColoredBox:public Box
{
    int color;
public:
    void SetColor(int c)
	{
        color=c;
    }
    int GetColor() {return color;}
};
// 在main()中测试基类和派生类
main(void)
{
    //声明并使用ColoredBox类的对象
    ColoredBox cbox;
    cbox.SetColor(3);       //使用自己的成员函数
    cbox.SetWidth(15);     //使用基类的成员函数
    cbox.SetHeight(10);    //使用基类的成员函数
 
    cout<<"cbox:"<<endl;
    cout<<"Color:"<<cbox.GetColor()<<endl;    //使用自己的成员函数
    cout<<"Width:"<<cbox.GetWidth()<<endl;   //使用基类的成员函数
    cout<<"Height:"<<cbox.GetHeight()<<endl;  //使用基类的成员函数
    //cout<<cbox.width; Error!  
}
#endif

派生类与基类private

#if 0
/*派生类与基类private*/
#include<iostream>
using namespace std;
//基类First
class First 
{
    int val1;
public:
    SetVal1(int v) 
	{
        val1=v;
    }
    void show_First(void) 
	{
        cout<<"val1="<<val1<<endl;
    }
};
//派生类Second
class Second:private First //private模式
{   
    int val2;
public:
    void SetVal2(int v1,int v2) 
	{
        SetVal1(v1);     //可见，合法
        val2=v2;
    }
    void show_Second(void) 
	{
    // cout<<"val1="<<val1<<endl; 不能访问First私有成员
        show_First();
        cout<<"val2="<<val2<<endl;
    }
};
main() 
{
    Second s1;
    //s1.SetVal1(1);    //不可见，非法
    s1.SetVal2(1,2);    //合法
    //s1.show_First();  //不可见，非法
    s1.show_Second();
}
#endif

派生类与public

#if 0
/*派生类与public*/
#include<iostream>
using namespace std;
//基类First
class First 
{
    int val1;
public:
    SetVal1(int v) 
	{
        val1=v;
    }
    void show_First(void) 
	{
        cout<<"val1="<<val1<<endl;
    }
};
//派生类Second
class Second:public First //public模式
{  
    int val2;
public:
    void SetVal2(int v1,int v2) 
	{
        SetVal1(v1);     //可见，合法
        val2=v2;
    }
    void show_Second(void) {
    // cout<<"val1="<<val1<<endl; 不能访问First私有成员
        show_First();
        cout<<"val2="<<val2<<endl;
    }
};
main() 
{
    Second s1;
    //调用Second类定义的成员函数
    s1.SetVal2(2,3);    
    cout<<"s1.show_Second():"<<endl;
    s1.show_Second();

    //调用First类定义的成员函数
    s1.SetVal1(10);  
    cout<<"s1.show_First():"<<endl;	
    s1.show_First(); 
}
#endif

多重派生类

#if 0
/*多派生类*/
#include<iostream>
using namespace std;
//定义最底层基类，它作为其他类的基类
class First 
{
    int val1;
public:
    First(void) 
	{
        cout<<"The First initialized"<<endl;
    }
};
//定义派生类，它作为其他类的基类
class Second :public First 
{   
    int val2;
public:
    Second(void) 
	{
        cout<<"The Second initialized"<<endl;
    }
};
//定义最上层派生类
class Three :public Second 
{
    int val3;
public:
    Three() 
	{
        cout<<"The Three initialized"<<endl;
    }
};
//定义各基类的对象，测试构造函数的执行情况
//定义各基类的对象，测试构造函数的执行情况
main() { 
	cout<<"First f1;"<<endl;
    First f1;
    cout<<"Second s1;"<<endl;
    Second s1;
    cout<<"Three t1;"<<endl;
    Three t1;
}
#endif

派生类有、无参构造函数

#if 0
/*派生类有/无参构造函数*/
#include<iostream>
using namespace std;
//定义基类First
class First 
{
    int  num;
    float grade;
public:
    //构造函数带参数
    First(int n,float v ) : num(n),grade(v)
    {
        cout<<"The First initialized"<<endl;
    }
    DispFirst(void) 
	{
        cout<<"num="<<num<<endl;
        cout<<"grade="<<grade<<endl;
    }
};

//定义派生类Second
class Second :public First 
{  
    double val;
public:
    //无参数构造函数，要为基类的构造函数设置参数
    Second(void):First(1000,0) 
	{
        val=1.0;
        cout<<"The Second initialized"<<endl;
    }

    //带参数构造函数，为基类的构造函数设置参数
    Second(int n,float x,double dx):First(n,x) 
	{
        val=dx;
        cout<<"The Second initialized"<<endl;
    }
    Disp(char *name)
	{
        cout<<name<<".val="<<val<<endl;
        DispFirst();
    }
};

//main()函数中创建和使用派生类对象
main() 
{
    //调用派生类的无参数构造函数
	cout<<"Second s1;"<<endl;
    Second s1;
	cout<<"s1.Disp(\"s1\");"<<endl;
	s1.Disp("s1");

    //调用派生类的有参数构造函数
	cout<<"Second s2(10002,95.7,3.1415926); "<<endl;
    Second s2(1002,95.7,3.14159); 
	cout<<"s2.Disp(\"s2\");"<<endl;	
    s2.Disp("s2");
}
#endif

#if 0
#include<iostream>
using namespace std;
//定义最低层基类First，它作为其他类的基类
class First 
{
    int val1;
public:
    First() 
	{
        cout<<"The First initialized"<<endl;
    }
    ~First() 
	{
        cout<<"The First destroyed"<<endl;
    }
};
//定义派生类Second，它作为其他类的基类
class Second :public First 
{   //默认为private模式
    int val2;
public:
    Second() 
	{
        cout<<"The Second initialized"<<endl;
    }
    ~Second() 
	{
        cout<<"The Second destroyed"<<endl;
    }
};
//定义最上层派生类Three
class Three :public Second 
{
    int val3;
public:
    Three() 
	{
        cout<<"The Three initialized"<<endl;
    }
    ~Three() 
	{
        cout<<"The Three destroyed"<<endl;
    }
};
//main()函数中测试构造函数和析构函数的执行情况
main() 
{ 
    Three t1;
    cout<<"---- Use the t1----"<<endl;
}
#endif

派生类与protected

#if 0
/*派生类与protected*/
#include<iostream>
using namespace std;
//基类
class First 
{
    int val1;
protected:
    void SetVal1(int v) 
	{
        val1=v;
    }
public:
    show_First(void) 
	{
        cout<<"val1="<<val1<<endl;
    }
};
//派生类
class Second:public First 
{   
    int val2;
protected:
    void SetVal2(int v) 
	{
        SetVal1(v);  //使用First 基类的保护成员
        val2=v;
    }
public:
    show_Second(void) 
	{
        show_First();
        cout<<"val2="<<val2<<endl;
    }
};
//派生类
class Third:public Second 
{   
    int val3;
public:
    void SetVal3(int n) 
	{
         SetVal1(n);  //使用First 基类的保护成员
         SetVal2(n);  //使用Second基类的保护成员
         val3=n;
    }
    show_Third(void) 
	{
        show_Second();
        cout<<"val3="<<val3<<endl;
    }
};
//main()函数的定义
main(void)
{
    First f1;
    //f1.SetVal1(1);   不可访问

    Second s1;
    //s1.SetVal1(1);   不可访问
    //s1.SetVal2(2);   不可访问

    Third  t1;
    //t1.SetVal1(1);   不可访问
    //t1.SetVal2(2);   不可访问
    t1.SetVal3(10);

	//显示t1对象的数据
	cout<<"t1.show_Third();"<<endl;
    t1.show_Third();
    cout<<"t1.show_Second();"<<endl;
    t1.show_Second();
    cout<<"t1.show_First();"<<endl;
    t1.show_First();
}
#endif

C++基础实例-类(6)

标签：

原文地址：http://blog.csdn.net/qq_28796345/article/details/51318044