C++语言面向对象程序设计实验

简介: C++语言面向对象程序设计实验

实验1:C++循环程序设计

1、

1、求a+aa+aaa+aaaa+… …+aa…a(n个),其中a为1~9之间的整数。例如:当a = 1, n = 3时,求1+11+111之和;当a = 5, n = 6时,求5+55+555+5555+55555+5555555之和。

#include<iostream>
using namespace std;
int main()
{
  int i,n,a,b;
  float sum;
  cin>>a>>n;
  sum=0;
  b=a;
  for(i=0;i<n;i++)
  {
    sum=sum+a;
    a=a*10+b;
  }
  cout<<sum<<endl;
  return 0;
}

2、

2、由0到4五个数字,组成五位数,每个数字用一次,但十位和百位不能为3(当然万位不能为0),输出所有可能的五位数。

#include<iostream>
using namespace std;
int main()
{
 //a,b,c,d,e分别是个位 十位 百位 千位 万位
 //e = 1 2 3 4
 //d = 0 1 2 3 4
 //c = 0 1 2 4
 //b = 0 1 2 4
 //a = 0 1 2 3 4 
 int num = 0;
 int a[5] = {0,1,2,3,4};//个位
 int b[4] = {0,1,2,4};//十位
 int c[4] = {0,1,2,4};//百位
 int d[5] = {0,1,2,3,4};//千位
 int e[4] = {1,2,3,4};//万位
 for(int e1 = 0;e1 < 4;e1++)
 {
  for(int d1 = 0;d1< 5;d1++)
  {
   for(int c1 = 0;c1 < 4;c1++)
   {
    for(int b1 = 0;b1 < 4;b1++)
    {
     for(int a1 = 0;a1 < 5;a1++)
     {
      if(a[a1]!=b[b1] && a[a1]!=c[c1] && a[a1]!=d[d1] && a[a1]!=e[e1] && b[b1]!=c[c1] && b[b1]!=d[d1] && b[b1]!=e[e1] && c[c1]!=d[d1] && c[c1]!=e[e1] && d[d1]!=e[e1])//每一位不能重复
      {
          num = e[e1]*10000+d[d1]*1000+c[c1]*100+b[b1]*10+a[a1];
          cout<<num<<" ";
      }
     }
    }
   }
  }
 }
 return 0;
}

心得

第一次体验C++开心

C++与C不同之处总结:

①最前面的头文件相似但有不同之处;

②输入cin>>;输出cout;这里的<<,>>本来是向前向后移动,但现在运算符重载,作为输入输出流的一部分;

③主函数为int型,记得return 0;

④大部分可以参照C,没有那么难,但也要沉进去。

实验2:数值数据输入与输出

编写一个程序,首先输入一个任意字符串,当输入1时,去掉该字符串最前面的“”,输入2时,去掉字符串中间的“”,输入3时,去掉最右端的“”,输入4时,去掉该字符串中的全部“”,输入5时,程序退出。(要求:5个子功能全部采用子函数来实现,字符串要求使用指针来进行操作)

#include <iostream>
#include <string.h>
using namespace std;
void fuc1(char *a);
void fuc2(char *a);
void fuc3(char *a);
void fuc4(char *a);
int main()
{
    int choice,count=0;
    char *a;
    char b[100];
    a=b;
  cout<<"请输入待处理字符串:";
    cin>>b;
    do{
    cout<<"*************************"<<endl;
        cout<<"*    1、去掉前面的*     *"<<endl;
        cout<<"*    2、去掉中间的*     *"<<endl;
        cout<<"*    3、去掉后面的*     *"<<endl;
        cout<<"*    4、去掉全部*       *"<<endl;
        cout<<"*    5、退出            *"<<endl;
        cout<<"**************************"<<endl;
    cout<<endl;
        if(count==0) cout<<"请输入你的选择(1-5):";
        else cout<<"请再次输入你的选择(1-5):";
        cin>>choice;
    cout<<endl;
        switch (choice)
        {
    case 1:
        fuc1(b);
        break;
    case 2:
        fuc2(b);
        break;
    case 3:
        fuc3(b);
        break;
    case 4:
        fuc4(b);
        break;
    default:
        break;
    }
    count++;
    }while(choice!=5);
  cout<<"程序退出中。。。。。。。。。。"<<endl;
    return 0;
}
/*     1、去掉前面的*       */
void fuc1(char *a)     
{
    int i,flag=0,j=0;
    char c[100];
    for(i=0;i<strlen(a);i++)
    {   
        if(a[i]!='*') flag=1;
    if(flag==1)
    {
      c[j]=a[i];
      j++;
    }
  }
  cout<<"结果字符串为:";
    for(i=0;i<j;i++)
    {
        cout<<c[i];
    }
    cout<<endl;
   cout<<endl;
}
/*    2、去掉中间的*     */
void fuc2(char *a)     
{
    int i,count=0,begin=0,end=0;
    char c[100];
    for(i=0;i<strlen(a);i++)
    {   
    if(a[i]!='*')
    {
      begin=i;
      break;
    }
  }
  for(i=strlen(a)-1;i>=0;i--)
    {   
    if(a[i]!='*')
    {
      end=i;
      break;
    }
  }
  for(i=0;i<strlen(a);i++)
    {   
    if(a[i]=='*'&&i>begin&&i<end) continue;
    c[count]=a[i];
    count++;  
  }
  cout<<"结果字符串为:";
    for(i=0;i<count;i++)
    {
        cout<<c[i];
    }
    cout<<endl;
   cout<<endl;
}
/*    3、去掉后面的*     */
void fuc3(char *a)   
{
    int i,j=0,flag=0,count=0;
    char c[100];
    char d[100];
    for(i=strlen(a)-1;i>=0;i--)
    {
        c[j]=a[i];
        j++;
    }
    for(i=0;i<strlen(a);i++)
    {   
        if(c[i]!='*') flag=1;
        if(flag==0) continue;
        d[count]=c[i];
        count++;
    }
  cout<<"结果字符串为:";
    for(i=count-1;i>=0;i--)
    {
        cout<<d[i];
    }
    cout<<endl;
   cout<<endl;
}
/*    4、去掉全面*       */
void fuc4(char *a)
{
    int i,j=0;
    char c[100];
    for(i=0;i<strlen(a);i++)
    {
        if(a[i]!='*')
        {
            c[j]=a[i];
            j++;
        }
    }
  cout<<"结果字符串为:";
    for(i=0;i<j;i++)
    {
        cout<<c[i];
    }
    cout<<endl;
   cout<<endl;
}

心得

本实验难点:循环语句

这题是在请教同学之后思考写出来的,过程有点艰辛。

对于超出凭看就能有思路的题目,可以先想清白每一个循环的内在逻辑,画好逻辑图或者用伪代码先弄一下。

对于自己思考很久还弄不出来的题,及时请教老师同学,不遗留问题。根据点拨自己再次思考,一般情况下就没有其他问题了。但是,对于这类题目,要注意定期回顾,隔段时间再看,观察自己是否已经掌握了这类题的解决方案,有思路,能写代码,无报错,如果有报错,及时总结,对比发现是新报错还是之前出现,如果出现过,以后遇到类似代码部分要更谨慎。

实验3:类与对象的定义与使用

定义一个学生成绩类Score,描述学生成绩的私有数据成员为学号(No)、姓名(Name[8])、数学(Math)、物理(Phi)、数据结构(Data)、平均分(ave)。定义能输入学生成绩的公有成员函数Write(),能计算学生平均分的公有成员函数Average(),能显示学生成绩的公有成员函数Display()。在主函数中用Score类定义学生成绩对象数组s[3]。用Write()输入学生成绩,用Average()计算每个学生的平均分,最后用Display()显示每个学生的成绩。

实验数据:

No Name Math Phi Data Ave

1001 Zhou 80 70 60

1002 Chen 90 80 85

1003 Wang 70 75 89

//***************
//**  1.cpp  **
//***************
#include<iostream>
#include "1.h"
#include<string.h>
using namespace std;
#include<iomanip>
void Score::Write(int a,char b[],double c,double d,double e)
{
  No=a;
  strcpy(Name,b);
  Math=c;
  Phi=d;
  Data=e;
}
void Score::Average()
{
  ave=(Math+Phi+Data)/3;  //平均值的计算
}
void Score::Display()
{
  cout<<setw(8)<<No<<setw(6)<<Name<<setw(6)<<Math<<setw(6)<<Phi<<setw(6)<<Data<<setw(6)<<ave<<endl;
} 
//***************
//**  2.cpp  **
//***************
#include<iostream>
#include "1.h"
#include<string.h>
using namespace std;
#include<iomanip>
void main()
{
  Score s[3];
  s[0].Write(1001,"Zhou",80,70,60);
  s[1].Write(1002,"Chen",90,80,85);
  s[2].Write(1003,"Wang",70,75,89);
  s[0].Average();
  s[1].Average();
  s[2].Average();
  cout<<setw(8)<<"No"<<setw(6)<<"Name"<<setw(6)<<"Math"<<setw(6)<<"Phi"<<setw(6)<<"Data"<<setw(6)<<"Ave"<<endl;
  s[0].Display();
  s[1].Display();
  s[2].Display();
}
//***************
//**   1.h   **
//***************
#include<iostream>
#include<string.h>
using namespace std;
class Score{
private:
  int No;  //学号
  char Name[8];  //姓名
  double Math;  //数学
  double Phi;  //物理
  double Data;  //数据结构
  double ave;  //平均分
public:
  void Write(int a,char b[],double c,double d,double e);  //输入学生成绩
  void Average();  //计算学生平均分
  void Display();  //显示每个学生的成绩};

心得

初步掌握类与对象的定义与使用方法,构造函数、拷贝构造函数的定义与使用方法,构函数的定义与使用方法。理解构造函数与析构函数的调用过程。

所遇问题及改进:

①关于带参构造函数的char初始化

void Score::Write(int a,char b[],double c,double d,double e)
 {
  No=a;   
  strcpy(Name,b);

注意b[]和stcpy;

如果报错:不能将第二个参数从char型变量参数 转化成

静态(const)char指针变量、意思是说你那个地方本来应该用char指针的,但你给的是个char型变量.你把你的参数写成&c(假设你那里用的变量名是c)。

考虑【】

②” ” s[0].Write(1001,“Zhou”,80,70,60);

③setw记得头文件#include

cout<<setw(8)<<“No”<<setw(6)<<“Name”<<setw(6)<<“Math”<<setw(6)<<“Phi”<<setw(6)<<“Data”<<setw(6)<<“Ave”<<endl;

④注意.h文件头文件不能互引自己本身 如果报错:#include nesting level is 362 deep; possible

infinite recursion 就是因为这个原因

实验4:类的组合定义与访问

建立一个存放素数的类Prime,具体要求如下。

①私有数据成员。

int a[100]:存放指定范围内的所有素数。

int n1,n2:存放指定范围的下限和上限

int num:存放素数的个数。

②公有成员函数

Prime(int m1,int m2):构造函数,用参数m1、m2初始化n1、n2,同时初始化num。

void primef():求指定范围内的所有素数,把它们依次存放在数组a中。并将求出的素数个数赋给num。

void show():显示求出的素数的个数及所有的素数,每行输出5个素数。

③在主函数中定义一个Prime类的对象p(100,200),通过p调用成员函数完成求素数及输出素数的工作。

//***************
//**  1.cpp  **
//***************
#include<iostream>
#include<cmath>
#include "1.h"
using namespace std;
void Prime::primef()
{
  int k;
  for(int i=n1;i<=n2;i++)
  {
    k=0;
    for(int j=2;j<sqrt(i);j++)
      if(i%j==0)
      {
        k=1;
        break;
      }
      if(k==0)
        a[num++]=i;
  }
}
void Prime::show()
{
  for(int i=0;i<num;i++)
  {
    if(i%5==0)
    {
      cout<<endl;
    }
    cout<<a[i]<<' ';
  }
  cout<<endl;
}
//***************
//**  2.cpp  **
//***************
#include<iostream>
#include "1.h"
using namespace std;
void main()
{
  Prime p(100,200);
  p.primef();
  p.show();
}
//***************
//**   1.h   **
//***************
class Prime{
public:
  Prime(int m1,int m2):n1(m1),n2(m2),num(0) {} //构造函数,用参数m1、m2初始化n1、n2,同时初始化num
  void primef();  //求指定范围内的所有素数,把它们依次存放在数组a中。并将求出的素数个数赋给num
  void show();  //显示求出的素数的个数及所有的素数,每行输出5个素数
private:
  int a[100];  //存放指定范围内的所有素数
  int n1,n2;  //存放指定范围的下限和上限
  int num;  //存放素数的个数
};

理解无参构造函数与带参构造函数的区别,掌握类的组合的定义,掌握对象成员的初始化方法。

实验5:静态成员函数设计

编写一个程序,输入N个学生数据,包括学号、姓名、C++成绩, 要求输出这些学生的数据、平均分与成绩等级。 提示:

1)设计一个学生类Stud,除了包括id(学号)、name(姓名)和C(成绩)数据成员外, 还有两个静态成员数据sum和num,分别存放总分和人数,

2)另有两个普通成员函数setdata()和print(),分别用于给数据成员赋值和输出数据成员的值, 另有一个静态成员函数avg(),它用于计算平均分,并输出平均分。

3)同时设计一个友元函数,输出成绩对应的等级: 大于等于90:优;8090:良;7079:中;60~69:及格;小于60:不及格。

4)在main()函数中定义了一个对象数组(不少于5个学生,各数据值自己确定),用于存储输入的学生数据,设计一个完整的程序。

//***************
//**  1.cpp  **
//***************
#include<iostream>
#include<iomanip>
#include "1.h"
using namespace std;
void Stud::setdata()
{
  cout<<"Please input Student id,name,C according to the order:";
  cin>>id>>name>>C;
}
void Stud::print()
{
   cout<<setw(10)<<name<<setw(6)<<id<<setw(8)<<C<<setw(8)<<level<<endl;
}
void Stud::total()
{
  sum+=C;
  num++;
}
float Stud::avg()
{
  return sum/num;
}
void Level(Stud &s)
{
  if(s.C>=90)
    strcpy(s.level,"优");
  else if(s.C>=80)
    strcpy(s.level,"良");
  else if(s.C>=70)
    strcpy(s.level,"中");
  else if(s.C>=60)
    strcpy(s.level,"及格");
  else
    strcpy(s.level,"不及格");
}
//***************
//**  2.cpp  **
//***************
#include<iostream>
#include "1.h"
#include<iomanip>
#include<string.h>
using namespace std;
int Stud::sum=0;
int Stud::num=0;
int main()
{
  int i;
  Stud *p=new Stud[6];  //定义了一个对象数组,用于存储输入的学生数据
  for(i=0;i<6;i++)
  {
    (p+i)->setdata();
    (p+i)->total();
  }
   cout<<setw(10)<<"姓名"<<setw(6)<<"学号"<<setw(8)<<"C++成绩"<<setw(8)<<"等级"<<endl;
  for(i=0;i<6;i++)
  {
    Level(*(p+i));
    (p+i)->print();
  }
  cout<<"Average C score: "<<Stud::avg()<<endl;
  return 0;
}
//***************
//**   1.h   **
//***************
class Stud{
public:
  void setdata();  //给数据成员赋值
  void print();  //输出数据成员的值
  void total();
  static float avg();  //计算平均分,并输出平均分
  friend void Level(Stud &);  //输出成绩对应的等级
private:
  int id;  //学号
  char name[20];  //姓名
  float C; //C++成绩
  char level[10];  //等级
  static int sum;  //总分
  static int num;  //人数
};

理解静态成员的概念,掌握静态函数的定义与调用方法;对象数组、对象指针及其使用方法;

例:(友元函数)friend void Level(Stud &); //输出成绩对应的等级

实验6:运算符重载

下面是一个整型数组类intArray的声明,请给出该类所有数据成员的类外定义。要求:

(1)能通过对“>>”、“<<”的重载实现数组元素的直接输入及其输出。输入时,第一次输入的值为数组长度,后面连续输入若干个数作为数组内容。输出时,首先提示该数组元素个数,然后依次输出该数组各元素;

(2)重载“=”、“+”、“-” 运算符使之能对两个数组类对象进行直接赋值、加减运算。

(3)写出主函数对该类进行测试。要求:

1)先构造包含10个数组元素的数组对象a,再调用流提取运算符重载函数实现a的元素初始化(元素值分别为1—10),输出a数组;

2)并利用a来构造数组b,输出数组b,并调用get函数获取b中下标为奇数的各元素值并输出,然后调用set函数将上述元素值乘以2,输出b数组;

3)构造一个包含5个元素的数组c,其值全为1,输出该数组,再调用ReSize函数将其大小重置为10,调用“=”重载函数将a的值复制给c,输出数组c;

4)分别将b+c,b-c的值送给数组d和数组e,并输出结果。

class intArray
{public:
intArray(int size);//构造函数
intArray(const intArray &x);//复制构造函数
~intArray();//析构函数
bool Set(int i, int elem);//设置第i个数组元素的值,设置成功返回true,失败返回false
bool Get(int i, int &elem); //获取第i个数组元素的值,获取成功返回true,失败返回false
int Length( ) const;//获取数组的长度
void ReSize ( int size ); //重置数组
intArray &operator=(const intArray &other);  //赋值运算符“=”重载函数
intArray &operator+(const intArray &other);   //加运算符“=”重载函数
intArray &operator-(const intArray &other) ;  //减运算符“=”重载函数
friend istream & operator>>(istream &, intArray &);  //数组的整体输入
friend ostream & operator<<(ostream &, intArray &);  //数组的整体输出
private:
int *element;            //指向动态数组的指针
int arraysize;            //数组的当前长度
};
//***************
//**  1.cpp  **
//***************
#include <iostream.h>
#include "1.h"
int intArray::Length() const
{
  return arraysize;
}
intArray intArray::operator + (const intArray &other)
{                            //数组元素对应相加
  intArray s=other;
  int i;
  for(i=0;i<other.arraysize;i++)
  {
    s.element[i]=element[i]+other.element[i];
  }
  return s;
}
intArray intArray::operator - (const intArray &other)
{                                                 //数组元素对应相减
  intArray s=other;
  int i;
  for(i=0;i<other.arraysize;i++)
  {
    s.element[i]=element[i]-other.element[i];
  }
  return s;
}
intArray intArray::operator = (const intArray &other)
{                                                 //相似的进行赋值
  element=other.element;
  arraysize=other.arraysize;
  return *this;
}
void intArray::ReSize (int size)
{
  delete[] element;
  element=new int[size];            //重置指针大小
  arraysize=size;
}
bool intArray::Set(int i, int elem)
{
  if(i<arraysize)
  {
    element[i]=element[i]*elem;
    return true;
  }
  else
  {
    return false;
  }
}
bool intArray::Get(int i, int &elem)
{
  if(i<arraysize)
  {
    elem=element[i];
    return true;
  }
  else
  {
    return false;
  }
}
intArray::intArray(int size)             //构造函数
{
  arraysize=size;
  element=new int[size];
}
intArray::intArray(const intArray &x)    //拷贝构造函数
{
  arraysize=x.arraysize;
  element=x.element;
}
intArray::intArray()                //不带参的构造函数
{
  arraysize=0;
  element=new int[0];
}
//***************
//**  2.cpp  **
//***************
#include <iostream.h>
#include "1.h"
ostream & operator<<(ostream &output, intArray &s) 
{                 //重载流插入运算符
  int i;
  output<<"数组的长度是"<<s.arraysize<<" "<<"数组:";
  for(i=0;i<s.arraysize;i++)
  {
    output<<s.element[i]<<" ";
  }
  output<<endl;
  return output;
}
istream & operator>>(istream &input, intArray &s)
{                 //重载流提取运算符
  int i=0,n;
  cout<<"第一次输入的值为数组长度,后面连续输入若干个数作为数组内容"<<endl;
  input>>n;
  intArray temp(n);
  s=temp;
  for(i=0;i<s.arraysize;i++)
  {
    input>>s.element[i];
  }
  return input;
}
int main()
{
  int i,temp;
  intArray a;
  cin>>a;
  cout<<a;
  intArray b=a;
  cout<<b;
  cout<<"Get函数的结果:";
  for(i=0;i<10;i++)
  {
    if(i%2!=0&&b.Get(i,temp)==1)
    {
      cout<<temp<<" ";
    }
  }
  for(i=0;i<10;i++)
  {
    if(i%2!=0)
    {
      b.Set(i,2);
    }
  }
  cout<<b;
  intArray c;
  cin>>c;
  cout<<c;
  c.ReSize(10);
  c=a;
  cout<<c;
  intArray d=b+c;
  cout<<d;
  intArray e=b-c;
  cout<<e;
  return 0;
}
//***************
//**   1.h   **
//***************
#include <iostream.h>
class intArray{
public:
  intArray();
  intArray(int size);  //构造函数
  intArray(const intArray &x);  //复制构造函数
  friend istream & operator>>(istream &, intArray &);  //数组的整体输入
  friend ostream & operator<<(ostream &, intArray &);  //数组的整体输出
  bool Set(int i, int elem);  //设置第i个数组元素的值,设置成功返回true,失败返回false
  bool Get(int i, int &elem);  //获取第i个数组元素的值,获取成功返回true,失败返回false
  void ReSize(int size);  //重置数组
  intArray operator = (const intArray &other);  //重载赋值运算符“=”
  intArray operator + (const intArray &other);  //重载加运算符“+”
  intArray operator - (const intArray &other);  //重载减运算符“=”
  int Length() const;  //获取数组的长度
private:
  int *element;  //指向动态数组的指针
  int arraysize;  //数组的当前长度
};

很有些难度,修改比写的时间要长

实验7:虚函数的使用

编程完成如下要求

(1)假设已有一个CShape图形类,并满足如下要求:1)CShape类有一个纯虚函数CountArea,能够计算图形的表面积;2)CShape类有一个纯虚函数CountVolume,能够计算图形的体积;

(2)由CShape类派生立方体CCube类,该类满足如下要求:1)CCube类有一个带参数的构造函数,其参数分别对应于立方体的长、宽、高;2)用一个成员函数来实现对立方体长、宽、高的设置;3)重载CShape类的CountArea和CountVolume,分别完成立方体的表面积和体积的计算。

(3)由CShape类派生球体CSphere类,该类满足如下要求:1)CSphere类有一个带参数的构造函数,其参数对应于球体的半径;2)用一个成员函数来实现对球体半径的设置;3)重载CShape类的CountArea和CountVolume,分别完成球体的表面积和体积的计算。

(4)实现一个main函数,在main函数中至少完成如下工作:1)实例化一个CCube类的对象a_cube和CSphere类的对象b_sphere;2)定义一个CShape类的指针p;3)将a_cube的长、宽和高分别设置为4、5和6;将p指向a_cube,通过p将a_cube的表面积和体积打印到屏幕上;4)将b_sphere的半径设置为7;将p指向b_sphere,通过p将b_sphere的表面积和体积打印到屏幕上。

//***************
//**  1.cpp  **
//***************
#include <iostream>
#include "1.h"
#include "2.h"
#include "3.h"
using namespace std;
void CSphere::CountArea()  //计算表面积
{
  cout<<"area: "<<4*3.14159*radius*radius<<endl;
}
void CSphere::CountVolume()  //计算体积
{
  cout<<"volume: "<<4/3*3.14159*radius*radius*radius<<endl;
}
void CSphere::Getsphere(double r)
{
  radius=r;
}
void CCube::Getcube(double X,double Y,double Z)
{
  x=X;
  y=Y;
  z=Z;
}
void CCube::CountArea()  //计算表面积
{
  cout<<"area: "<<2*(x*y+x*z+y*z)<<endl;
}
void CCube::CountVolume()  //计算体积
{
  cout<<"volume: "<<x*y*z<<endl;
}
//***************
//**  2.cpp  **
//***************
#include <iostream>
#include "1.h"
#include "2.h"
#include "3.h"
using namespace std;
int main()
{
  CCube a_cube;
  CSphere b_sphere;
  CShape *p;                   //定义的Shape类指针
  a_cube.Getcube(4,5,6);
  p=&a_cube;
  p->CountArea();
  p->CountVolume();
  b_sphere.Getsphere(7);
  p=&b_sphere;
  p->CountArea();
  p->CountVolume();
  return 0;
}
//***************
//**   1.h   **
//***************
class CShape{
public:
  virtual void CountArea()=0;  //纯虚函数声明
  virtual void CountVolume()=0;
};
//***************
//**   2.h   **
//***************
class CCube: public CShape{
public:
  CCube(double X=0,double Y=0,double Z=0):x(X),y(Y),z(Z){}  //带默认参数的使用初始化列表的构造函数
  void Getcube(double X=0,double Y=0,double Z=0);  //计算体积
  virtual void CountArea();
  virtual void CountVolume();
protected:  
  double x;
  double y;
  double z;
};
//***************
//**   3.h   **
//***************
class CSphere: public CShape{
public:
  CSphere(double r=0):radius(r){}  //带默认参数的使用初始化列表的构造函数
  void Getsphere(double r);
  virtual void CountArea();
  virtual void CountVolume();
protected:
  double radius;
};

多态性,纯虚函数的使用,抽象类

目录
相关文章
|
6月前
|
C++
C++ 语言异常处理实战:在编程潮流中坚守稳定,开启代码可靠之旅
【8月更文挑战第22天】C++的异常处理机制是确保程序稳定的关键特性。它允许程序在遇到错误时优雅地响应而非直接崩溃。通过`throw`抛出异常,并用`catch`捕获处理,可使程序控制流跳转至错误处理代码。例如,在进行除法运算或文件读取时,若发生除数为零或文件无法打开等错误,则可通过抛出异常并在调用处捕获来妥善处理这些情况。恰当使用异常处理能显著提升程序的健壮性和维护性。
103 2
|
1月前
|
C++ 芯片
【C++面向对象——类与对象】Computer类(头歌实践教学平台习题)【合集】
声明一个简单的Computer类,含有数据成员芯片(cpu)、内存(ram)、光驱(cdrom)等等,以及两个公有成员函数run、stop。只能在类的内部访问。这是一种数据隐藏的机制,用于保护类的数据不被外部随意修改。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。成员可以在派生类(继承该类的子类)中访问。成员,在类的外部不能直接访问。可以在类的外部直接访问。为了完成本关任务,你需要掌握。
68 19
|
1月前
|
存储 编译器 数据安全/隐私保护
【C++面向对象——类与对象】CPU类(头歌实践教学平台习题)【合集】
声明一个CPU类,包含等级(rank)、频率(frequency)、电压(voltage)等属性,以及两个公有成员函数run、stop。根据提示,在右侧编辑器补充代码,平台会对你编写的代码进行测试。​ 相关知识 类的声明和使用。 类的声明和对象的声明。 构造函数和析构函数的执行。 一、类的声明和使用 1.类的声明基础 在C++中,类是创建对象的蓝图。类的声明定义了类的成员,包括数据成员(变量)和成员函数(方法)。一个简单的类声明示例如下: classMyClass{ public: int
50 13
|
1月前
|
编译器 数据安全/隐私保护 C++
【C++面向对象——继承与派生】派生类的应用(头歌实践教学平台习题)【合集】
本实验旨在学习类的继承关系、不同继承方式下的访问控制及利用虚基类解决二义性问题。主要内容包括: 1. **类的继承关系基础概念**:介绍继承的定义及声明派生类的语法。 2. **不同继承方式下对基类成员的访问控制**:详细说明`public`、`private`和`protected`继承方式对基类成员的访问权限影响。 3. **利用虚基类解决二义性问题**:解释多继承中可能出现的二义性及其解决方案——虚基类。 实验任务要求从`people`类派生出`student`、`teacher`、`graduate`和`TA`类,添加特定属性并测试这些类的功能。最终通过创建教师和助教实例,验证代码
50 5
|
1月前
|
存储 C++
【C++面向对象——输入输出流】处理二进制文件(头歌实践教学平台习题)【合集】
本任务要求使用C++读取二进制文件并在每行前添加行号后输出到控制台。主要内容包括: 1. **任务描述**:用二进制方式打开指定文件,为每一行添加行号并输出。 2. **相关知识**: - 流类库中常用的类及其成员函数(如`iostream`、`fstream`等)。 - 标准输入输出及格式控制(如`cin`、`cout`和`iomanip`中的格式化函数)。 - 文件的应用方法(文本文件和二进制文件的读写操作)。 3. **编程要求**:编写程序,通过命令行参数传递文件名,使用`getline`读取数据并用`cout`输出带行号的内容。 4. **实验步骤**:参考实验指
38 5
|
1月前
|
存储 算法 搜索推荐
【C++面向对象——群体类和群体数据的组织】实现含排序功能的数组类(头歌实践教学平台习题)【合集】
1. **相关排序和查找算法的原理**:介绍直接插入排序、直接选择排序、冒泡排序和顺序查找的基本原理及其实现代码。 2. **C++ 类与成员函数的定义**:讲解如何定义`Array`类,包括类的声明和实现,以及成员函数的定义与调用。 3. **数组作为类的成员变量的处理**:探讨内存管理和正确访问数组元素的方法,确保在类中正确使用动态分配的数组。 4. **函数参数传递与返回值处理**:解释排序和查找函数的参数传递方式及返回值处理,确保函数功能正确实现。 通过掌握这些知识,可以顺利地将排序和查找算法封装到`Array`类中,并进行测试验证。编程要求是在右侧编辑器补充代码以实现三种排序算法
40 5
|
1月前
|
Serverless 编译器 C++
【C++面向对象——类的多态性与虚函数】计算图像面积(头歌实践教学平台习题)【合集】
本任务要求设计一个矩形类、圆形类和图形基类,计算并输出相应图形面积。相关知识点包括纯虚函数和抽象类的使用。 **目录:** - 任务描述 - 相关知识 - 纯虚函数 - 特点 - 使用场景 - 作用 - 注意事项 - 相关概念对比 - 抽象类的使用 - 定义与概念 - 使用场景 - 编程要求 - 测试说明 - 通关代码 - 测试结果 **任务概述:** 1. **图形基类(Shape)**:包含纯虚函数 `void PrintArea()`。 2. **矩形类(Rectangle)**:继承 Shape 类,重写 `Print
48 4
|
1月前
|
设计模式 IDE 编译器
【C++面向对象——类的多态性与虚函数】编写教学游戏:认识动物(头歌实践教学平台习题)【合集】
本项目旨在通过C++编程实现一个教学游戏,帮助小朋友认识动物。程序设计了一个动物园场景,包含Dog、Bird和Frog三种动物。每个动物都有move和shout行为,用于展示其特征。游戏随机挑选10个动物,前5个供学习,后5个用于测试。使用虚函数和多态实现不同动物的行为,确保代码灵活扩展。此外,通过typeid获取对象类型,并利用strstr辅助判断类型。相关头文件如&lt;string&gt;、&lt;cstdlib&gt;等确保程序正常运行。最终,根据小朋友的回答计算得分,提供互动学习体验。 - **任务描述**:编写教学游戏,随机挑选10个动物进行展示与测试。 - **类设计**:基类
32 3
|
6月前
|
算法 C语言 C++
C++语言学习指南:从新手到高手,一文带你领略系统编程的巅峰技艺!
【8月更文挑战第22天】C++由Bjarne Stroustrup于1985年创立,凭借卓越性能与灵活性,在系统编程、游戏开发等领域占据重要地位。它继承了C语言的高效性,并引入面向对象编程,使代码更模块化易管理。C++支持基本语法如变量声明与控制结构;通过`iostream`库实现输入输出;利用类与对象实现面向对象编程;提供模板增强代码复用性;具备异常处理机制确保程序健壮性;C++11引入现代化特性简化编程;标准模板库(STL)支持高效编程;多线程支持利用多核优势。虽然学习曲线陡峭,但掌握后可开启高性能编程大门。随着新标准如C++20的发展,C++持续演进,提供更多开发可能性。
109 0
|
4月前
|
算法 C++
2022年第十三届蓝桥杯大赛C/C++语言B组省赛题解
2022年第十三届蓝桥杯大赛C/C++语言B组省赛题解
99 5