关于抽象类

最新推荐文章于 2023-09-21 20:06:47 发布
最新推荐文章于 2023-09-21 20:06:47 发布
阅读量672 收藏
点赞数
分类专栏： C++ 文章标签： 类 c++ 重载运算符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013447446/article/details/28127605
版权

冒个泡吐舌头：最近学习了抽象类，及运算符的重载，很是费解C++的创始人是多么的牛叉

个人心得：

        ？=、[]、()、->以及所有的类型转换运算符只能作为成员函数重载，如果允许第一操作数不是

        同类对象，而是其他数据类型，

        则只能作为非成员函数重载（如输入输出流运算符>>和<<就是这样的情况）。

        重载双目运算符可以用友元或者成员函数，但是两者有区别。例如用成员函数重载了 + 之后

      （假设赋值运算符 = 已经被重载）
        ob = ob + 100是被支持的，而ob = 100 + ob就是不被允许的。这种情况下就要使用友元函数来

        对运算符重载以避免不必要的麻烦

对问题的描述如下： 

定义一个抽象基类AbsCollection，含有一个对集合的基本操作，例如添加一个元素add、删除一个元素Delete、删除所有removeAll、枚举enumerate、获得元素个数getCount、判断是否包含某个元素containsMember和两个集合是否相等isEqual等。重载+（并集）、-（差集）、*（交集）、<<（输出）、>>（输入），这些操作多数要定义成纯虚函数。抽象类应包含一个int型数组，用来存储集合中的元素，从抽象基类派生出Set类和Bag类，并覆盖所有派生而来的纯虚成员函数。写函数使用抽象基类AbsCollection写两个集合的并交差，在主函数中生成Set类和Bag类对象测试。

程序如下：

AbsCollection.h文件

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


class AbsCollection
{
    public:
        AbsCollection();
        int getcount();//返回长度
        void make_count(int x);//改变长度
        virtual void add(int x)=0;//纯虚函数
        void enumerate();//输出集合中的元素
        void Delete(int x);//删除元素
        void removeall();
        bool containmember(int x);//判断是否包含某个元素
        bool is_equal(int *s,int l);//判断是否相等
        virtual  AbsCollection& operator-(AbsCollection& x)=0;
        virtual AbsCollection& operator+(AbsCollection &x)=0;
        virtual AbsCollection& operator*(AbsCollection& x)=0;
        friend istream& operator>>(istream& in,AbsCollection& x);
        friend ostream& operator<<(ostream& out,AbsCollection& x);
        virtual ~AbsCollection();
        int a[100];
    private:
        int len;
};

#endif // ABSCOLLECTION_H

/**************************************************/
#ifndef SET_H
#define SEY_H
class Set:public AbsCollection
{
public:
    Set(){}
    Set(int *s,int l);
    void add(int x);
    AbsCollection& operator-(AbsCollection& x);
    AbsCollection& operator+(AbsCollection& x);//重载加号
    AbsCollection& operator*(AbsCollection& x);
    virtual ~Set();

};
#endif//SET_H
/*****************************************************/
#ifndef BAG_H
#define BAG_H
class Bag:public AbsCollection
{
public:
    Bag (){}
    Bag(int *s,int l);
    void add(int x);
    AbsCollection& operator*(AbsCollection& x);
    AbsCollection& operator-(AbsCollection& x);
    AbsCollection& operator+(AbsCollection& x);
    virtual ~Bag();
};
#endif // BAG_H

AbsCollection.cpp文件

#include "AbsCollection.h"
#include<iostream>
#include<string.h>
using namespace std;
Bag current;
Set present;
//AbsCollection &present;
/***************************************************************************/
AbsCollection::AbsCollection()
{
    len=0;
}
int AbsCollection::getcount()
{
    return len;
}
void AbsCollection::make_count(int x)
{
    len=x;
}
void AbsCollection::enumerate()
{
    int i;
    for(i=0;i<len;i++)
        cout<<a[i]<<" ";
    if(len==0)  cout<<"无元素";
    cout<<endl;
}
void AbsCollection::Delete(int x)
{
    int i,j,f=0;
    //cin>>x;
    for(i=0;i<len;i++)
    {
        if(a[i]==x)
        {
            f=1;
            break;
        }
    }
    if(f==1)
    {
        for(j=i;j<len-1;j++)
            a[j]=a[j+1];
        len--;
    }
    else
        cout<<"此元素不存在\n";
}
bool AbsCollection::containmember(int x)
{
    int f=0;
    //cin>>x;
    for(int i=0;i<len;i++)
        if(a[i]==x)
            {
                f=1;break;
            }
    if(f)
        return true;
    else return false;
}
void AbsCollection::removeall()
{
    len=0;
}
bool AbsCollection::is_equal(int *s,int l)
{
    int i,j,q[l],k=0;
    if(l!=len)  return false;
    memset(q,0,l);
    for(i=0;i<len;i++)
    {
        for(j=0;j<l;j++)
        {
            if(a[i]==s[j]&&q[j]==0)
            {
                k++;
                q[j]=1;
            }
        }
    }
    if(k==len)  return true;
    else return false;
}
//AbsCollection& AbsCollection::operator-(AbsCollection& x)
//{
//    AbsCollection& present=*this;
//    int i,l=x.getcount();
//    for(i=0;i<l;i++)
//    {
//        if(present.containmember(x.a[i]))
//            present.Delete(x.a[i]);
//    }
//    return present;
//}
AbsCollection::~AbsCollection(){}
/***************************************************************************/
Set::Set(int *s,int l)//集合中没有重复元素
{
    int i,j,t=0,k=getcount();
    for(i=0;i<l;i++)
    {
        t=0;
        for(j=0;j<k;j++)
        {
            if(s[i]==a[j])
            {
                t=1;
                break;
            }
        }
        if(!t)
        {
            a[k++]=s[i];
        }
    }
    make_count(k);
}
void Set::add(int x)//元素不能重复
{
    int i,k=getcount();
    for(i=0;i<k;i++)
    {
        if(a[i]==x)
        {
            cout<<"此元素已存在"<<endl;
            return ;
        }
    }
    a[k++]=x;
    make_count(k);
}
AbsCollection& Set::operator-(AbsCollection& x)
{
    present=*this;
    int i,l=x.getcount();
    for(i=0;i<l;i++)
    {
        if(present.containmember(x.a[i]))
            present.Delete(x.a[i]);
    }
    return present;
}
AbsCollection& Set::operator+(AbsCollection& x)
{
    present=*this;
    int k=present.getcount(),i,j,f,l=x.getcount();
    for(i=0;i<l;i++)
    {
        f=0;
        for(j=0;j<k;j++)
        {
            if(x.a[i]==present.a[j])
            {
                f=1;
                break;
            }
        }
        if(f==0)
            present.a[k++]=x.a[i];
    }
    present.make_count(k);
    return present;
}
AbsCollection& Set::operator*(AbsCollection& x)
{
    present=*this;
    int i,l=x.getcount(),s[100],t=0;
    for(i=0;i<l;i++)
    {
        if(present.containmember(x.a[i]))
            s[t++]=x.a[i];
    }
    present.removeall();
    for(i=0;i<t;i++)
        present.add(s[i]);
    return present;
}
Set::~Set(){}
istream& operator>>(istream& in,AbsCollection& x)
{
    int n,t;
    cout<<"输入元素个数:";
    cin>>n;
    cout<<"输入元素:";
    while(n--)
    {
        cin>>t;
        x.add(t);
    }
    return in;
}
ostream& operator<<(ostream& out,AbsCollection& x)
{
    x.enumerate();
    return out;
}
/**********************************************************************************/

Bag::Bag(int *s,int l)
{
    make_count(l);
    int i,k=getcount();
    for(i=0;i<k;i++)
        a[i]=s[i];
}
void Bag::add(int x)
{
    int k=getcount();
    make_count(k+1);
    a[k]=x;
}
AbsCollection& Bag::operator-(AbsCollection& x)
{
    current=*this;
    int i,l=x.getcount();
    for(i=0;i<l;i++)
    {
        if(current.containmember(x.a[i]))
            current.Delete(x.a[i]);
    }
    return current;
}
AbsCollection& Bag::operator+(AbsCollection& x)
{
    current=*this;
    int i,k=current.getcount(),l=x.getcount();
    for(i=0;i<l;i++)
     current.a[k++]=x.a[i];
    current.make_count(k);
    return current;
}
AbsCollection& Bag::operator*(AbsCollection& x)
{
    current=*this;
    int i,l=x.getcount(),s[100],t=0;
    for(i=0;i<l;i++)
    {
        if(current.containmember(x.a[i]))
            s[t++]=x.a[i];
    }
    current.removeall();
    for(i=0;i<t;i++)
        current.add(s[i]);
    return current;
}
Bag::~Bag(){}

main.cpp文件

#include <iostream>
#include"AbsCollection.h"
using namespace std;

int main()
{
//    int m[4]={1,2,3,4},n[5]={0,0,1,2,3};
//    Set s1(m,4);
//    Set s2(n,5);
//    Bag b1(n,5);
//    Bag b2(m,4);
    Set s1,s2;
    Bag b1,b2;
    cout<<"输入集合S1：\n";
    cin>>s1;
    cout<<"输入集合S2：\n";
    cin>>s2;
    cout<<"输入包裹b1：\n";
    cin>>b1;
    cout<<"输入包裹b2：\n";
    cin>>b2;
    cout<<"输出集合S1：";
    cout<<s1;
    cout<<"输出集合S2：";
    cout<<s2;
    cout<<"输出包裹b1：";
    cout<<b1;
    cout<<"输出包裹b2：";
    cout<<b2;
    cout<<"两个集合s1,s2的交集"<<endl;
    (s1+s2).enumerate();
    cout<<"两个包裹b1,b2的交集"<<endl;
    (b1+b2).enumerate();
    cout<<"两个集合s1,s2的差集"<<endl;
    (s1-s2).enumerate();
    cout<<"两个包裹b1,b2的差集"<<endl;
    (b1-b2).enumerate();
    cout<<"两个集合S1,s2的交集"<<endl;
    (s1*s2).enumerate();
    cout<<"两个包裹b1,b2的交集"<<endl;
    (b1*b2).enumerate();
//    /***********对当前的元素的输出*********************/
//    cout<<"输出当前集合s1:  ";
//    s1.enumerate();
//    cout<<"输出当前包裹b1:  ";
//    b1.enumerate();
//    /************添加元素********************************/
//    cout<<"添加元素到集合s1:(输入元素)";
//    cin>>x;
//    s1.add(x);
//    cout<<"输出当前集合s1:  ";
//    s1.enumerate();
//    cout<<"添加元素到包裹b1:(输入元素)";
//    cin>>x;
//    b1.add(x);
//    cout<<"输出当前包裹b1:  ";
//    b1.enumerate();
//    /********************删除元素***************************/
//    cout<<"删除集合s1中的元素：";
//    s1.Delete();
//    cout<<"输出当前集合s1:  ";
//    s1.enumerate();
//    cout<<"删除包裹b1中的元素：";
//    b1.Delete();
//    cout<<"输出当前包裹b1:  ";
//    b1.enumerate();
//    /*********************删除所有元素**************************/
//    cout<<"删除集合s1的所有元素\n";
//    s1.removeall();
//    cout<<"输出当前集合s1:  ";
//    s1.enumerate();
//    cout<<"删除包裹b1的所有元素\n";
//    b1.removeall();
//    cout<<"输出当前包裹b1:  ";
//    b1.enumerate();
    return 0;
}




 

Baby_Snow
关注
专栏目录
java关于接口正确的说法是_Java中关于抽象类和接口的说法，多选题
weixin_42298424的博客
02-25 5223
展开全部答案：ABCFJava 抽象类在面向对象的概念中，所有的对象都是通过类来32313133353236313431303231363533e58685e5aeb931333431343036描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方...
（重载+、*、-、＜＜、=）操作符重载、函数模板、类中有指针变量联合使用
weixin_44190648的博客
03-16 446
函数功能： 实现集合的并集（重载+号）、交集（重载*号）、补集（重载-号） 文件目录： 1.set.h #pragma once #ifndef _SET #define _SET #include <iostream> using namespace std; template<class T> class set { public: //友元函数、在实现类模板时，前面必须加上 template<typename T> template<typename
重载运算符“+”、“*”、“-”实现集合的并集、交集、差集运算
zutuan5的专栏
11-15 6926
<br />#include<iostream> #include<string> using namespace std; class A { public: void getdata()//输入数组元素 { cout<<"请输入集合中的元素："; gets(data); } void print( )//输出数组元素 { puts(data); } A ope
关于抽象类的描述
gf_gxh的博客
07-11 2194
1、在抽象类中，初始化变量后不可再在抽象类中进行赋值或者是操作该变量，要想操作此变量则在其子类中进行操作2、在抽象类中，可以声明一个抽象方法也可以声明一个普通方法。但声明抽象方法时不可在本类中对其实现（即没有方法体）。有抽象方法的一定是抽象类，但是在抽象类中不一定有抽象方法。3、抽象类可以被实例化（多态），但是实例化后不一定有意义。...
Java关于抽象类的几个问题，抽象类存在的意义？抽象方法有什么意义？
weixin_42412021的博客
04-08 1497
1 请问定义抽象类、抽象方法使用的关键字是什么？ abstract 2 请问定义抽象类存在的意义？ 抽象类存在的意义是被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西抽象类中已经是具体的实现（抽象类中可以有成员变量和实现方法），而模板中不能决定的东西定义成抽象方法，让使 用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。 3 请问定义抽象方法...
抽象类
Riven_x的博客
10-26 1156
1.1 概述 1.1.1 抽象类引入 父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类完全只需要提供一个没有方法体的方法签名即可，具体实现交给子类自己去实现。我们把没有方法体的...
java抽象类可以实例化_Java关于抽象类能否被实例化的问题
weixin_35713375的博客
02-15 1892
转载：http://blog.csdn.net/zhanzhan0329/article/details/9173419首先明确地说：抽象类不能被实例化。我对抽象类能否被实例化产生疑问始于我看到一句话说：子类实例化会先实例化父类。而且，自己也知道，抽象类作为父类，其子类是能调用他的属性和已实现方法的。这证明抽象父类在内存是有一定空间的。(百度百科说：实例化其实就是在内存中开放一个空间用于存储新的产...
接口与抽象类的区别
热门推荐
DavidLiu的博客
12-01 3万+
a、抽象类不能被实例化只能被继承； b、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法； c、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public； d、一个子类继承一个抽象类，则子类必须实现父类抽象方法，否则子类也必须定义为抽象类； e、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。 接口：Java中接口使用interface关键字修饰，特点为: a、接口可以包含变量、方法；变量被隐士指定为public st.
什么是抽象类
flf1234567898的博客
08-11 1385
定义： 含有纯虚函数 的类称为抽象类，它不能生成对象。 什么是纯虚函数？ 纯虚函数是在基类声明的虚函数，它在基类中没有定义，但是要求派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后面添加“=0” 比如 virtual void f()=0; 而c++中包含纯虚函数的类称为抽象类，由于抽象类中包含了没有定义的纯虚函数，所以不能定义抽象类的对象。 总结：1.抽象类只能用作其他类的基类，不能定义抽象类的对象。 2.抽象类不能用于参数类型、函数返回值或显示转换的类型 3.抽象类可以定义抽象类的
【JAVA】关于抽象类的概念
weixin_73602725的博客
09-21 2154
在Java中，抽象类是一种特殊的类，它无法被实例化。它只能被用作其他类的基类，以便子类可以继承它的属性和方法。今天我们就来谈谈JAVA中的抽象类。
关于抽象类的java实验 Animal
11-29
这个实验“关于抽象类的Java实验Animal”旨在帮助我们理解如何在Java中使用抽象类以及多态性概念。在这个实验中，我们定义了一个名为`Animal`的抽象类，并从它派生出三个具体的子类：`Dog`、`Cat`和`Duck`。每个子类...
关于抽象类和接口的两篇不错文章
04-28
### 关于抽象类和接口的两篇不错文章 #### 一、理解抽象类与接口的基础概念 在面向对象编程中，抽象类与接口是两个重要的概念，它们在Java语言中有着特殊的实现方式。抽象类（Abstract Class）和接口（Interface）...
C#中实现抽象类里建立静态方法
09-04
在C#编程语言中，抽象类（abstract class）是一种特殊类型的类，它不能被实例化，但可以作为其他类的基类。抽象类通常用来定义一个类的公共接口，其中可以包含抽象方法（abstract methods），这些方法没有具体的实现...
7. 吴恩达机器学习课程-作业7-Kmeans and PCA
wujing1_1的博客
02-22 1057
fork了别人的项目，自己重新填写，我的代码如下 https://gitee.com/fakerlove/machine-learning/tree/master/code 代码原链接 文章目录7. 吴恩达机器学习课程-作业7-Kmeans and PCA7.1 k-means7.1.1 题目介绍7.1.2 算法流程7.1.3 实现k-means7.1.4 测试7.2 图像压缩与k-均值7.3 PCA7.3.1 题目介绍7.3.2 算法流程7.3.3 代码1) 示例数据集2) 实现PCA3) 脸图像数据集
算法提高分类学习刷题——1.动态规划——1.3背包模型
m0_51474171的博客
02-25 3526
（1）01背包 模型 题目介绍 有 N件物品和一个容量为 V 的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。 「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。 动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i个物品的做出决策，「0-1」正好代表不选与选两种决定。 二维 （1）状态f[i][j]定义：前i个物品，背包容量j下的最优解（最大价值）： 当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开.
算法提高分类学习刷题——1.动态规划——1.2.最长上升子序列模型
m0_51474171的博客
02-21 1491
最长上升子序列模型 1.最长上升子序列 题目描述 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤1000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 解题思路 因为以i结尾的子序列，一定是由前i-1个数结尾的子序列长度加一取max 比如一个子序列a[j]a[i] ,那么当a[j]<a[i
类和对象进阶
sqjddb的博客
02-23 538
/关于访问限定符的几点说明 /类的实例化 /计算类对象的大小 /深入理解this指针 /六大默认成员函数 /const修饰成员函数 /细谈成员函数 /对象成员的初始化 /static成员 /友元 /内部类
经典的图像分类模型
最白の白菜的博客
02-22 5382
目录经典的图像分类模型AlexNetAlexNet的网络架构手写数字势识别数据读取模型编译模型训练模型评估VGGVGG的网络架构手写数字势识别数据读取模型编译模型训练模型评估GoogLeNetInception 块GoogLeNet模型B1模块B2模块B3模块B4模块B5模块手写数字识别数据读取模型编译模型训练模型评估延伸版本InceptionV2InceptionV3ResNet残差块ResNet模型手写数字势识别数据读取模型编译模型训练模型评估 经典的图像分类模型 AlexNet 学习目标 知道Ale
下列关于抽象类的说法哪一个是错误的。 A. 含抽象方法的类为抽象类 B. 抽象类能创建(new)实例 C. 子类有未实现父类的抽象方法时仍为抽象类 D. 子类实现所有抽象方法时不再是抽象类
最新发布
11-20
下列关于抽象类的说法错误的是B. 抽象类能创建(new)实例。 解释：抽象类是一种不能被实例化的类，它的存在就是为了被继承。抽象类中可以包含抽象方法，这些方法只有声明，没有具体的实现。抽象类的作用是为了规范...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值