C++中的结构到底可不可以继承？

个人看来，在C++中结构和类没有太大的区别，或者说存在如下区别：

在结构中成员默认为public访问，类中为private访问方式

实际上，类与结构的惟一区别在于：在默认状态下，结构的所有成员均是公有的，而类的所有成员是私有的。除此之外，类与结构是等价的，也就是说，一个结构定义了一个类的类型。

C++结构具有如下特性：
a、结构可以包含各种类型成员，也可以加入private,protected,public等修饰符

1. 简单类型成员
2. 函数
3. 函数指针
4. 其他结构类型的成员
5. 其他类的对象成员
6. 本结构类型的指针

struct A
{
    //简单类型
    int a;
    int b;

    //函数
    void TestP(void)
    {
        cout<<"Hello world"<<endl;
    }

    //函数指针
    void (*pFunc)(void);

    //其他结构类型成员
    struct Friend f;

    //其他类的对象
    Test t;

    //声明友元类
    friend Test;

    //声明友元结构
    friend struct Friend; 

    //构造函数和析构函数
    A(int a,int b);
    virtual ~A();

    //虚函数，实现多态
    virtual void Display(void);
};

b、结构可以继承，甚至可以多继承，虚继承，多态，重载运算符，定义友元函数，友元类等。

下面采用实际例子测试：（环境：win7+vs2012）

// 结构和类.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
using namespace std;
class Test
{

};

struct Friend
{
};
//--------------------------------------------------定义父结构A-----------------------------------------------------
struct A
{
    //简单类型
    int a;
    int b;

    //函数
    void TestP(void)
    {
        cout<<"Hello world"<<endl;
    }

    //函数指针
    void (*pFunc)(void);

    //其他结构类型成员
    struct Friend f;

    //其他类的对象
    Test t;

    //声明友元类
    friend Test;

    //声明友元结构
    friend struct Friend; 

    //构造函数和析构函数
    A(int a,int b);
    virtual ~A();

    //虚函数，实现多态
    virtual void Display(void);
};

A::A(int a,int b)
{
    this->a=a;
    this->b=b;
    cout<<"A Constructor..."<<endl;
}

A::~A()
{
    cout<<"A De_Constructor"<<endl;
}

void A::Display(void)
{
    cout<<"Virtual Func A"<<endl;
}

//--------------------------------------------------结构B继承A-----------------------------------------------------

struct B : public A//这里可以使用virtual，即可以使用虚继承 
{
    int c;
    B(int a,int b,int c);
    virtual ~B();

    virtual void Display(void);
    friend istream& operator >>(istream& in,struct B &b);
    friend ostream& operator <<(ostream& out,struct B &b);
};

B::B(int a,int b,int c):A(a,b)
{
    this->c=c;
    cout<<"B Constructor..."<<endl;
}
B::~B()
{
    cout<<"B De_Constructor"<<endl;
}

void B::Display(void)
{
    cout<<"Virtual Func B"<<endl;
}

istream& operator >>(istream& in, struct B &b)
{
    cout<<"输入a,b,c"<<endl;
    in>>b.a>>b.b>>b.c;
    return in;
}

ostream& operator <<(ostream& out, struct B &b)
{
    out<<"a: "<<b.a<<"\tb: "<<b.b<<"\tc: "<<b.c<<endl;
    return out;
}

//--------------------------------------------------结构C继承B-----------------------------------------------------

struct C:public B
{
    char d;
    C(int a,int b,int c,char d);
    virtual ~C();

    void Display(void);
};

void C::Display(void)
{
    cout<<"Virtual Func C"<<endl;
}

C::C(int a,int b,int c,char d):B(a,b,c)
{
    this->d=d;
    cout<<"C Constructor"<<endl;
}

C::~C()
{
    cout<<"C De_Constructor"<<endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
    struct B testB(1,2,3);
    struct C testC(11,12,13,'a');

    //重载输入输出>>,<<
    cout<<testB;
    cin>>testB;
    cout<<testB;

    testB.Display();

    //多态特性
    struct A *pA=&testC;
    struct B *pB=&testC;
    cout<<testC;
    pA->Display();
    pB->Display();

    return 0;
}

运行结果：

看看虚函数表：