c++对结构体的扩充以及类的介绍

作业：

使用C++手动封装一个顺序表，包含成员指针变量，成员变量N个

验证模块（主函数）

#include <iostream>
#include "seqlist.h"

int main()
{
    SeqList A(5);
    A.myshow();
    cout<<"返回值为："<<A.empty()<<endl;   //验证判空
    A.myshow();
    cout<<"返回值为："<<A.add(78)<<endl;   //添加 len = 1
    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.add(45)<<endl;   //len = 3
    A.myshow();

    cout<<"返回值为："<<A.empty()<<endl;   //验证判空
    A.myshow();
    cout<<"返回值为："<<A.full()<<endl;    //验证判满
    A.myshow();
    cout<<"返回值为："<<A.insert_pos(3,999)<<endl; //验证插入
    A.myshow();
    cout<<"返回值为："<<A.delete_pos(0)<<endl; //验证删除
    A.myshow();
    cout<<"返回值为："<<A.at(6)<<endl; //验证任意访问
    A.myshow();
    cout<<"返回值为："<<A.at(1)<<endl;
    A.myshow();


    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.full()<<endl;    //验证判满
    A.myshow();
    A.expend(); //验证二倍扩容

    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.add(78)<<endl;
    cout<<"返回值为："<<A.full()<<endl;    //验证判满
    A.myshow();


    return 0;
}

功能模块

#include "seqlist.h"

//判空函数
bool SeqList:: empty()
{
    if(len==0)
    {
        cout<<"为空"<<endl;
        return true;
    }
    return false;
}
//判满函数
bool SeqList:: full()
{
    if(size<=len)
    {
      cout<<"为满"<<endl;
      return true;
    }
    return false;
}
//添加数据函数
bool SeqList:: add(datatype e)
{
    //是否符合条件
    if(full())
    {
        cout<<"添加失败"<<endl;
        return false;
    }
    //添加数据
    data[len] = e;
    len++;
    return true;
}
//求当前顺序表的实际长度
int SeqList:: length()
{
    //求实际长度

    return len;
}


//任意位置插入函数
bool SeqList:: insert_pos(int pos, datatype e)
{
    //是否符合条件
    if(full()||pos>size||pos<=0)
    {
        cout<<"插入失败"<<endl;
        return false;
    }
    //插入功能
    for(int i=len;i>pos-1;i--)
    {
        data[i] = data[i-1];
    }
    data[pos-1] = e;
    len++;
    return true;
}
//任意位置删除函数
bool SeqList:: delete_pos(int pos)
{
    if(empty())
    {
        cout<<"删除失败"<<endl;
        return false;
    }
    for(int i=pos-1;i<len;i++)
    {
        data[i]=data[i+1];
    }
    len--;
    return true;
}
//访问容器中任意一个元素 at
datatype  &SeqList:: at(int index)
{
    if(index<0||index>size)
    {
        return data[-1];
    }
    for(int i=0;i<len;i++)
    {
        if(index==data[i])
        {
            return data[i];
        }
    }
    return data[-1];
}

//君子函数：二倍扩容
void SeqList:: expend()
{
    int newsize =  2*size;  //新的容量
    datatype * newdata = new datatype[newsize]; //分配新的内存
    for(int i=0;i<len;i++)
    {
        newdata[i] = data[i];   //复制旧的数据到新的表中

    }
    delete[] data;  //销毁旧的表
    data = newdata; //更新指针
    size = newsize; //更新容量
}

//释放顺序表
void SeqList:: seqfree()
{
    delete []data;
}

//展示所有元素
void SeqList:: myshow()
{
    for(int i=0;i<len;i++)
    {
        cout<<data[i]<<" ";
        if(i%10==0&&i!=0)
        {
            cout<<endl;
        }
    }
    cout<<endl;
}

头文件模块

#ifndef SEQLIST_H
#define SEQLIST_H
#include <iostream>
using namespace std;

#define MY_M 10
//类型重命名
using datatype = int;     //typedef int datatype;

//定义一个顺序表类
class SeqList
{
    private:
        datatype *data;                //指向堆区空间的指针
        int size = 0;                      //数组的大小
        int len = 0;                     //顺序表实际长度


     public:
         //无参构造
        SeqList():data(new datatype[MY_M]), size(MY_M), len(0)
        {
            cout<<"无参构造"<<endl;
        }
        //有参构造
        SeqList(int s):data(new datatype[s]), size(s), len(0)
        {
            cout<<"有参构造"<<endl;
        }

         //要实现的函数


         //判空函数
         bool empty();
         //判满函数
         bool full();
         //添加数据函数
         bool add(datatype e);
         //求当前顺序表的实际长度
         int length();


         //任意位置插入函数
         bool insert_pos(int pos, datatype e);
         //任意位置删除函数
         bool delete_pos(int pos);
         //访问容器中任意一个元素 at
         datatype &at(int index);

         //君子函数：二倍扩容
         void expend();

         //释放顺序表
         void seqfree();

         //访问全部元素
         void myshow();
};


#endif // SEQLIST_H

笔记

思维导图