网页资讯视频图片知道文库贴吧地图采购
进入贴吧全吧搜索
孙笑川吧 关注：7,351,530贴子：216,927,143
  • 3回复贴，共1页

福雨林耳鼻

只看楼主收藏回复

#include <iostream>
#include <cstring>
using namespace std;
class Person
{
public:
Person(const char* n, int i);
~Person();
void Display();
protected:
char* name;
int id;
};
class CollegeStu : public Person
{
public:
CollegeStu(const char* n, int i, const char* m, double s);
~CollegeStu();
void Display();
private:
char* major;
double score;
};
Person::Person(const char* n, int i)
{
name = new char[lbk]strlen(n) + 1[rbk];
strcpy(name, n);
id = i;
}
Person::~Person()
{
delete[lbk][rbk] name;
}
void Person::Display()
{
cout << "Name:" << name << endl;
cout << "ID:" << id << endl;
}
CollegeStu::CollegeStu(const char* n, int i, const char* m, double s) : Person(n, i)
{
major = new char[lbk]strlen(m) + 1[rbk];
strcpy(major, m);
score = s;
}
CollegeStu::~CollegeStu()
{
delete[lbk][rbk] major;
}
void CollegeStu::Display()
{
Person::Display();
cout << "Major:" << major << endl;
cout << "C++ Score:" << score << endl;
}
int main()
{
char name[lbk]81[rbk], major[lbk]81[rbk];
int id;
double score;
cin >> name >> id >> major >> score;
CollegeStu cs(name, id, major, score);
cs.Display();
return 0;
}
IP属地:辽宁来自iPhone客户端1楼2025-02-27 13:51回复
    #include <iostream>
    #include <string>
    using namespace std;
    class Person {
    protected:
    string name;
    string id;
    public:
    Person(string _name, string _id);
    void Display();
    ~Person();
    };
    class CollegeStu : public Person {
    private:
    string major;
    double score;
    public:
    CollegeStu(string _name, string _id, string _major, double _score);
    void Display();
    };
    Person::Person(string _name, string _id) {
    name = _name;
    id = _id;
    }
    // Person 类的显示函数在类外定义
    void Person::Display() {
    cout << "Name:" << name << endl;
    cout << "ID:" << id << endl;
    }
    // Person 类的析构函数在类外定义
    Person::~Person() {}
    // CollegeStu 类的构造函数在类外定义
    CollegeStu::CollegeStu(string _name, string _id, string _major, double _score)
    : Person(_name, _id) {
    major = _major;
    score = _score;
    }
    // CollegeStu 类的显示函数在类外定义
    void CollegeStu::Display() {
    Person::Display(); // 调用父类的 Display 函数
    cout << "Major:" << major << endl;
    cout << "C++ Score:" << score << endl;
    }
    int main() {
    string name, major;
    string id;
    double score;
    cin >> name >> id >> major >> score;
    CollegeStu cs(name, id, major, score);
    cs.Display();
    return 0;
    }
    IP属地:辽宁来自iPhone客户端2楼2025-02-27 13:57
    回复
      2025-12-12 19:58:22
      广告
      不感兴趣
      开通SVIP免广告
      1030
      #include <iostream>
      #include <string>
      using namespace std;
      //循环队列类
      const int QueueSize=100; //循环队列的最大长度
      template <class T> //定义模板类CirQueue
      class CirQueue
      {
      public:
      CirQueue( ); //构造函数，置空队
      ~ CirQueue( ); //析构函数
      void EnQueue(T x); //将元素x入队
      T DeQueue( ); //将队头元素出队
      T GetQueue( ); //取队头元素（并不删除）
      bool Empty( ); //判断队列是否为空
      bool Full();
      private:
      T data[QueueSize]; //存放队列元素的数组
      int front, rear; //队头和队尾指针，分别指向队头元素的前一个位置和队尾元素的位置
      };
      //功 能：初始化空队列
      template <class T>
      CirQueue<T>::CirQueue( )
      {
      front=rear=0;
      }
      // 功 能：销毁队列
      template <class T>
      CirQueue<T>::~CirQueue( )
      {
      }
      //功 能：元素x入队
      template <class T>
      void CirQueue<T>::EnQueue(T x)
      {
      if (Full()) throw "Overflow";
      rear=(rear+1) % QueueSize; //队尾指针在循环意义下加1
      data[rear]=x; //在队尾处插入元素
      }
      //功 能：队头元素出队，返回值为出队元素
      template <class T>
      T CirQueue<T>::DeQueue( )
      {
      if (Empty()) throw "Downflow";
      front=(front+1) % QueueSize; //队头指针在循环意义下加1
      return data[front]; //读取并返回出队前的队头元素，注意队头指针
      }
      //指向队头元素的前一个位置
      // 功 能：获取队头元素
      template <class T>
      T CirQueue<T>::GetQueue( )
      {
      int i;
      if (Empty()) throw "Downflow";
      i=(front+1) % QueueSize; //注意不要给队头指针赋值
      return data[i];
      }
      // 功 能：判断队列是否为空,若空返回true，否则返回false
      template <class T>
      bool CirQueue<T>::Empty( )
      {
      return front==rear;
      }
      //功 能：判断队列是否满，若满返回true，否则false
      template <class T>
      bool CirQueue<T>::Full()
      {
      return (rear+1)%QueueSize==front;
      }
      //Class MGraph
      const int MaxSize=20; //图中最多顶点个数
      int visited[MaxSize]; //访问标志数组（0表示未访问，1表示已访问）
      template <class T>
      class MGraph
      {
      public:
      MGraph(T a[],int n,int e); //构造函数，初始化具有n个顶点,e条边的图
      void DispMGraph(); //输出图中顶点值和矩阵值
      void DFSTraverse(int v); //从v顶点出发深度优先遍历图（一个连通子图）
      void BFSTraverse(int v); // 从v顶点出发广度优先遍历图（一个连通子图）
      private:
      T vertex[MaxSize]; //存放图中顶点信息的数组
      int arc[MaxSize][MaxSize]; //存放图中顶点关系（边）的数组
      int vertexNum,arcNum; //图的顶点数和边数
      };
      //构造一个邻接矩阵存储的无向图
      template <class T>
      MGraph<T>::MGraph(T a[], int n, int e)
      {
      vertexNum=n; //顶点数
      arcNum=e; //边数
      int i,j,k;
      for (i=0; i<vertexNum; i++)
      vertex[i]=a[i]; //顶点值
      for (i=0; i<vertexNum; i++) //初始化邻接矩阵值为0（顶点间无边）
      for (j=0; j<vertexNum; j++)
      arc[i][j]=0;
      for (k=0; k<arcNum; k++) //依次输入e条边
      {
      cin>>i>>j; //输入各条边依附的两个顶点的序号
      arc[i][j]=1; //置有边标志
      arc[j][i]=1;
      }
      }
      //输出图中所有顶点信息，和边信息
      template <class T>
      void MGraph<T>::DispMGraph( )
      {
      int i,j;
      cout<<" ";
      for(i=0;i<vertexNum;i++)
      cout<<vertex[i]<<" ";//输出图中所有的顶点
      cout<<endl;
      for(i=0;i<vertexNum;i++)
      {
      cout<<vertex[i]<<" ";
      for(j=0;j<vertexNum;j++)
      cout<<arc[i][j]<<" "; //输出边值（0/1）
      cout<<endl;
      }
      }
      //在此处实现深度优先遍历算法
      template <class T>
      void MGraph<T>::DFSTraverse(int v){
      int w;
      cout<<vertex[v]<<" ";
      visited[v]=1;
      for(w=0;w<vertexNum;w++){
      if(!visited[w]&&arc[v][w]){
      DFSTraverse(w);
      }
      }
      }
      //在此处实现广度优先遍历算法
      template <class T>
      void MGraph<T>::BFSTraverse(int v){
      CirQueue <int> Q;
      cout<<vertex[v]<<" ";
      visited[v]=1;
      Q.EnQueue(v);
      while(!Q.Empty()){
      v=Q.DeQueue();
      for(int w=0;w<vertexNum;w++)
      if(!visited[w]&&arc[v][w]){
      cout<<vertex[w]<<" ";
      visited[w]=1;
      Q.EnQueue(w);
      }
      }
      }
      int main()
      {
      string a[]={"A","B","C","D","E","F","G","H","I","J","K","L","M","N"}; //顶点信息
      int i,n,e;
      cin>>n>>e; //输入顶点个数和边个数
      MGraph<string> G(a,n,e);
      G.DispMGraph();
      for(i=0;i<n;i++)
      visited[i]=0;
      cout<<"DFS:";
      G.DFSTraverse(0);
      cout<<endl;
      for(i=0;i<n;i++)
      visited[i]=0;
      cout<<"BFS:";
      G.BFSTraverse(0);
      return 0;
      }
      IP属地:辽宁3楼2025-05-14 16:25
      回复
        1031
        //已知有向图采用邻接表存储，部分代码如下，请补充完成计算各个顶点的入度，出度算法。
        #include <iostream>
        #include <string>
        using namespace std;
        const int MaxSize=20; // 顶点个数的最大值
        int visited[MaxSize]; //访问标志数组（0表示未访问，1表示已访问）
        //定义边表结点
        struct ArcNode
        {
        int adjvex; //邻接点的序号
        ArcNode *next; //指向下一个边结点的指针
        };
        //定义顶点表结点
        template <class T>
        struct VertexNode
        {
        T vertex; //顶点的名称
        ArcNode *firstedge; //指向第一个边表结点的头指针
        };
        //邻接表类
        template <class T>
        class ALGraph
        {
        public:
        ALGraph(T a[ ], int n, int e); //构造函数，初始化一个有n个顶点e条边的图
        ~ALGraph(); //析构函数，释放邻接表中各边表结点的存储空间
        void DispALGraph(); //输出邻接表
        void CountInD(int ind[]); //计算各个顶点的入度,存储在ind中
        void CountOutD(int outd[]); //计算各个顶点的出度,存储在outd中
        private:
        VertexNode<T> adjlist[MaxSize]; //存放顶点表的数组
        int vertexNum, arcNum; //图的顶点数和边数
        };
        /*
        *前置条件：图不存在
        *输 入：无
        *功 能：图的初始化
        *输 出：无
        *后置条件：得到一个无向图
        */
        template <class T>
        ALGraph<T>::ALGraph(T a[ ], int n, int e)
        {
        arcNum = e; //边数
        vertexNum=n; //顶点数
        int i,j;
        for (i=0; i<vertexNum; i++)
        {
        adjlist[i].vertex = a[i];
        adjlist[i].firstedge = NULL;
        }
        for (int k=0; k<arcNum; k++) //依次输入每一条边，并在相应边表中插入结点
        {
        cin>>i>>j; //输入边所依附的两个顶点的序号
        ArcNode *s=new ArcNode;
        s->adjvex=j; //生成一个边表结点s
        s->next=adjlist[i].firstedge; //将结点s插入到i号表的头结点之后
        adjlist[i].firstedge=s;
        }
        }
        /* 前置条件：图已存在
        * 输 入：无
        * 功 能：销毁图
        * 输 出：无
        * 后置条件：释放图所占用的存储空间
        */
        template <class T>
        ALGraph<T>::~ALGraph( )
        {
        for (int i=0; i<vertexNum; i++)
        {
        ArcNode * p=adjlist[i].firstedge;
        while (p!=NULL) //循环删除
        {
        adjlist[i].firstedge=p->next;
        delete p; //释放结点空间
        p=adjlist[i].firstedge;
        }
        }
        }
        /*
        *前置条件：图已存在
        *输 入：无
        *功 能：输出图中所有顶点及边的数据信息
        *输 出：图中所有顶点及边的数据信息
        *后置条件：图保持不变
        */
        template <class T>
        void ALGraph<T>::DispALGraph( )
        {
        int i;
        ArcNode *p;
        cout<<"Graph adjlist:\n";
        for(i=0;i<vertexNum;i++){
        cout<<i<<" "<<adjlist[i].vertex<<" "; //输出图中顶点的序号i及值
        for(p=adjlist[i].firstedge;p;p=p->next)
        cout<<p->adjvex<<" "; //输出i号顶点的邻接点的序号
        cout<<endl;
        }
        }
        //计算各个顶点的入度
        template <class T>
        void ALGraph<T>::CountInD(int ind[])
        { int i,j,count=0; ArcNode *p;
        for(i=0;i<vertexNum;i++){
        count=0;
        for(j=0;j<vertexNum;j++){
        for(p=adjlist[j].firstedge;p;p=p->next)
        if(p->adjvex==i)
        count++;
        ind[i]=count;
        }
        }
        }
        //计算各个顶点的出度
        template <class T>
        void ALGraph<T>::CountOutD(int outd[])
        { int i,count=0; ArcNode *p;
        for(i=0;i<vertexNum;i++){
        count=0;
        for(p=adjlist[i].firstedge;p;p=p->next)
        count++;
        outd[i]=count;
        }
        }
        int main()
        {
        string a[]={"A","B","C","D","E","F","G","H","I","J","K","L","M","N"}; //顶点信息
        int i,n,e;
        cin>>n>>e; //输入顶点个数和边个数
        ALGraph<string> G(a,n,e);
        G.DispALGraph();
        int ind[MaxSize];
        cout<<"Indegree:";
        G.CountInD(ind);
        for(i=0;i<n;i++)
        cout<<ind[i]<<" ";// 输出各个顶点的入度
        cout<<endl;
        int outd[MaxSize];
        cout<<"OutDegree:";
        G.CountOutD(outd);
        for(i=0;i<n;i++)
        cout<<outd[i]<<" "; // 输出各个顶点的出度
        return 0;
        }
        IP属地:辽宁4楼2025-05-14 16:26
        回复

          扫二维码下载贴吧客户端

          下载贴吧APP
          看高清直播、视频！
          • 3回复贴，共1页
          发表回复
          发贴请遵守贴吧协议及“七条底线”贴吧投诉
          内  容:
            查看全部
          发 表
          保存至快速回贴

          发布成功
          去贴吧APP订阅抽奖结果通知
          扫码进入贴吧APP
          ···········
          开奖后第一时间站内信通知
          ···········
          中奖结果全员公示