D&A 5 Collection with Inheritance

最新推荐文章于 2016-12-30 16:47:29 发布
最新推荐文章于 2016-12-30 16:47:29 发布
阅读量421 收藏 1
点赞数
分类专栏： C++ 文章标签： inheritance
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/t6_17/article/details/51626362
版权

  真正面向对象的编程需要对象来支持三种特性：封装、继承和多态，多态性使许多实现的一个通用接口，并在不同的情况下，在不同的情况下采取行动。C++支持多种静态（编译时）和动态（运行时）的多态性，语言所支持的功能上面。编译时多态性不允许某些运行时的决定，而运行时多态性通常会导致性能损失。静态多态性不是真正的多态现象，包括函数重载，操作符重载和模板，这不是我们要做的工作（在这个问题）。动态多态性：变量的指针（引用）在C++基类类型可以引用任何派生类除了精确匹配变量类型的对象类型的对象。这允许数组和其他类型的容器将指针指向不同类型的对象。因为在运行时变量的赋值通常发生，这必然是一个运行时现象。C++还提供了一个dynamic_cast算子，使程序安全地尝试一个对象转换为一个更具体的对象类型的对象（而不是转换到一个更一般的类型，这是允许的）。此功能依赖于运行时类型信息（RTTI）。对象是某一特定类型也可以投，static_cast型，一个纯粹的编译时间构建没有运行时的开销，不需要RTTI。通常，当一个函数在派生类中重写基类中的函数，调用函数的对象的类型确定。一个给定的函数重写时存在的数量或功能的两个或两个以上的定义之间的参数类型没有区别。因此，在编译时，它可能不能够确定对象的类型，因此正确的函数调用，只给出一个基类的指针；因此，该决定是在运行时被关闭的。这就是所谓的动态调度。虚拟成员函数或方法[ 43 ]允许被调用的函数的最具体的实现，根据对象的实际运行时类型。在C++的实现，这是通常使用的虚拟函数表。如果对象的类型是已知的，这可能被绕过的前面加上一个完全限定类名前的函数调用，但一般调用虚函数在运行时确定。

  除了标准的成员函数、运算符重载和析构函数可以是虚的。作为一个经验法则，如果任何类中的函数是虚函数，析构函数应该一样。作为对象的类型，在编译时，构造函数和扩展复制构造函数不能是虚的。然而，当指向派生对象的指针被传递为基类对象的指针时，可能会出现一个对象的副本。在这种情况下，一般的解决方案是创建一个（）（或类似的）虚拟函数，创建并返回一个拷贝的派生类调用时。成员函数也可以用“纯虚拟的“附加它= 0右括号后的分号。一类包含纯虚函数称为抽象数据类型。不能从抽象数据类型中创建对象，它们只能来自于。任何派生类继承了虚函数为纯，并且必须提供一个非纯定义，它（和所有其他纯虚拟函数）在派生类的对象可以创建。试图创建一个类的对象的一个程序，一个纯虚拟成员函数或继承的纯虚拟成员函数是不成立的。


共有7个文件：

Collection.hpp

#ifndef COLLECTION_H_
#define COLLECTION_H_
typedef int E;
 
class Collection {
 public:
  Collection() {}
  virtual ~Collection(){};
  virtual void add(E e) = 0;
  virtual void clear(void) = 0;
  virtual bool contain(E e) = 0;
  virtual bool isEmpty(void) = 0;
  virtual void remove(int e) = 0;
  virtual int size(void) = 0;
};
 
#endif
List.hpp 

#ifndef LIST_H_
#define LIST_H_
 
#include <iostream>
#include "Collection.hpp"
 
class List : virtual public Collection {
 public:
  List() {}
  virtual ~List() {}
  virtual E& operator[](int index) = 0;
  virtual E& get(int index) = 0;
  virtual int indexOf(E element) = 0;
  virtual void sort(void) = 0;
};
 
#endif
Linkedlist.hpp 

#ifndef LINKEDLIST_H_
#define LINKEDLIST_H_
 
#include "List.hpp"
#include <iostream>
 
class LinkedList : virtual public List {
 public:
  typedef struct node {
    E data;
    struct node* next;
    struct node* prev;
    node(E data, struct node* next = NULL, struct node* prev = NULL)
        : data(data), next(next), prev(prev) {}
  } node;
  LinkedList();
  ~LinkedList();
  virtual void add(E e);
  virtual void clear(void);
  virtual bool contain(E e);
  virtual bool isEmpty(void);
  virtual void remove(E e);
  virtual E& operator[](int index);
  virtual E& get(int index);
  virtual int indexOf(E element);
  virtual void sort(void);
  virtual int size(void);
 
 private:
  node* head;
  node* tail;
  int _size;
};
 
#endif
Linkedlist.cpp 

#include "LinkedList.hpp"
#include <iostream>
 
LinkedList::LinkedList() : head(NULL), tail(NULL), _size(0) {}
 
LinkedList::~LinkedList() { this->clear(); }
 
void LinkedList::add(E e) {
  if (tail == NULL) {
    this->head = this->tail = new node(e);
  } else {
    this->tail->next = new node(e, NULL, tail);
    tail = tail->next;
  }
  this->_size++;
}
 
void LinkedList::clear(void) {
  node* p = this->head;
  while (p != NULL) {
    node* next = p->next;
    delete p;
    p = next;
  }
  this->head = this->tail = NULL;
  this->_size = 0;
}
 
bool LinkedList::contain(E e) {
  node* p = this->head;
  while (p != NULL) {
    if (p->data == e) {
      return true;
    }
    p = p->next;
  }
  return false;
}
 
bool LinkedList::isEmpty(void) { return this->_size == 0; }
 
void LinkedList::remove(E e) {
  node* p = this->head;
  while (p != NULL) {
    if (p->data != e) {
      p = p->next;
    } else {
      if (p == this->head) {
        this->head = this->head->next;
        if (this->head != NULL) {
          this->head->prev = NULL;
        }
        delete p;
        p = head;
      } else if (p == this->tail) {
        tail = tail->prev;
        tail->next = NULL;
        delete p;
        p = NULL;
      } else {
        p->next->prev = p->prev;
        p->prev->next = p->next;
        node* temp = p;
        p = p->next;
        delete temp;
      }
      this->_size--;
    }
  }
}
 
E& LinkedList::operator[](int index) { return this->get(index); }
 
E& LinkedList::get(int index) {
  node* p = this->head;
  int counter = 0;
  while (p != NULL) {
    if (counter == index) {
      return p->data;
    }
    counter++;
    p = p->next;
  }
  return *reinterpret_cast<E*>(NULL);
}
 
int LinkedList::indexOf(E element) {
  node* p = this->head;
  int index = 0;
  while (p != NULL) {
    if (p->data == element) {
      return index;
    } else {
      p = p->next;
      index++;
    }
  }
  return -1;
}
 
int LinkedList::size(void) {
  return this->_size;
}
 
void LinkedList::sort(void) {
  if (this->size() > 1) {
    node* fast = this->head;
    node* slow = this->head;
    LinkedList li_left;
    LinkedList li_right;
 
    li_left.head = this->head;
    while (fast != NULL && fast->next != NULL) {
      li_left._size++;
      fast = fast->next->next;
      slow = slow->next;
    }
    li_left.tail = slow->prev;
    li_left.tail->next = NULL;
 
    li_right.head = slow;
    li_right.head->prev = NULL;
    li_right.tail = this->tail;
    li_right._size = this->_size - li_left._size;
 
    this->head = NULL;
    this->tail = NULL;
 
    li_left.sort();
    li_right.sort();
 
    node* pointer_left = li_left.head;
    node* pointer_right = li_right.head;
 
    node* pointer_head = NULL;
    node* pointer_tail = NULL;
 
    while (pointer_left != NULL && pointer_right != NULL) {
      node* temp;
      if (pointer_left->data <= pointer_right->data) {
        temp = pointer_left;
        pointer_left = pointer_left->next;
      } else {
        temp = pointer_right;
        pointer_right = pointer_right->next;
      }
      if (pointer_head == NULL) {
        pointer_head = pointer_tail = temp;
      } else {
        pointer_tail->next = temp;
        temp->prev = pointer_tail;
        pointer_tail = temp;
      }
      pointer_head->prev = NULL;
      pointer_tail->next = NULL;
    }
 
    while (pointer_left != NULL) {
      pointer_tail->next = pointer_left;
      pointer_left->prev = pointer_tail;
      pointer_tail = pointer_left;
      pointer_left = pointer_left->next;
    }
 
    while (pointer_right != NULL) {
      pointer_tail->next = pointer_right;
      pointer_right->prev = pointer_tail;
      pointer_tail = pointer_right;
      pointer_right = pointer_right->next;
    }
 
    this->head = pointer_head;
    this->tail = pointer_tail;
 
    li_left.head = li_left.tail = NULL;
    li_right.head = li_right.tail = NULL;
  }
}
Arraylist.hpp 

#ifndef ARRAYLIST_H_
#define ARRAYLIST_H_
 
#include "List.hpp"
 
class ArrayList : public List {
 public:
  ArrayList();
  ~ArrayList();
  virtual void add(E e);
  virtual void clear(void);
  virtual bool contain(E e);
  virtual bool isEmpty(void);
  virtual void remove(E e);
  virtual E& operator[](int index);
  virtual E& get(int index);
  virtual int indexOf(E element);
  virtual void sort(void);
  virtual int size(void);
 
 private:
  E* storage;
  int _size;
  int _maxsize;
  static const int extend_factor = 2;
  void extend(void);
};
 
#endif
Arraylist.cpp 

#include "ArrayList.hpp"
#include <algorithm>
ArrayList::ArrayList() {
  this->storage = new E[65536]();
  this->_size = 0;
  this->_maxsize = 65536;
}
 
void ArrayList::extend(void) {
  int new_size = _maxsize * extend_factor;
  E* new_storage = new E[new_size]();
  for (int i = 0; i < this->_size; i++) {
    new_storage[i] = this->storage[i];
  }
  delete[] storage;
  storage = new_storage;
  _maxsize = new_size;
}
 
ArrayList::~ArrayList() {
  if (storage != NULL) {
    delete[] storage;
  }
}
 
void ArrayList::add(E e) {
  if (this->_size + 1 > this->_maxsize) {
    extend();
  }
  storage[this->_size] = e;
  _size++;
}
 
void ArrayList::clear(void) {
  delete this->storage;
  storage = new E[16]();
  _size = 0;
  _maxsize = 16;
}
 
bool ArrayList::contain(E e) {
  for (int i = 0; i < this->_size; i++) {
    if (this->storage[i] == e) {
      return true;
    }
  }
  return false;
}
 
bool ArrayList::isEmpty(void) { return (this->_size == 0); }
 
void ArrayList::remove(E e) {
  for (int i = 0; i < this->_size;) {
    if (this->storage[i] == e) {
      for (int j = i + 1; j < this->_size; j++) {
        this->storage[j - 1] = this->storage[j];
      }
      this->_size--;
    } else {
        i++;
    }
  }
}
 
E& ArrayList::operator[](int index) { return this->storage[index]; }
 
E& ArrayList::get(int index) { return this->storage[index]; }
 
int ArrayList::indexOf(E element) {
  for (int i = 0; i < this->_size; i++) {
    if (this->storage[i] == element) {
      return i;
    }
  }
  return -1;
}
 
int ArrayList::size(void) { return this->_size; }
 
static void swap(int* a, int* b) {
  if (a != b) {
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;
  }
}
 
static int partion(int* A, int from, int to) {
  // A[to] is the pivot
  int i = from, j = from - 1;
  for (; i < to; i++) {
    if (A[i] < A[to]) {
      j++;
      swap(&A[i], &A[j]);
    }
  }
  swap(&A[j + 1], &A[to]);
  return j + 1;
}
 
/*
 static int random_partion(int * A, int from, int to) {
    int r = getRandeomNum(from, to);
    swap(&A[r], &A[to]);
    return partion(A, from, to);
}
*/
 
static void qsort(int* A, int from, int to) {
  if (to > from) {
    int middle = partion(A, from, to);
    qsort(A, from, middle - 1);
    qsort(A, middle + 1, to);
  }
}
 
void ArrayList::sort(void) { qsort(this->storage, 0, this->_size - 1); }
main.cpp 

#include <iostream>
#include <cstdlib>
#include "Collection.hpp"
#include "List.hpp"
#include "LinkedList.hpp"
#include "ArrayList.hpp"
#include <exception>
 
using std::cin;
using std::cout;
using std::endl;
using std::exception;
 
class AlgorithmnForbidden : public exception {
  virtual const char *what() const throw() {
    return "Please do not use std::sort or std::list or std::vector .....";
  }
};
 
class TEST {
 private:
  int *testData;
  int data_size;
 
 public:
  TEST() {
#if defined(_GLIBCXX_ALGORITHM) || defined(_GLIBCXX_LIST) || \
    defined(_GLIBCXX_VECTOR)
    //throw AlgorithmnForbidden();
    cout << "please do not use algorithm" << endl;
#endif
    cin >> data_size;
    cout << "test data size:" << data_size << endl;
    testData = new int[data_size];
    for (int i = 0; i < data_size; i++) {
      cin >> testData[i];
    }
  }
 
  ~TEST() { delete[] testData; }
 
  void test_List(Collection *c) {
    cout << (c->isEmpty() ? "true" : "false") << endl;
 
    int n = data_size;
 
    for (int i = 0; i < n; i++) {
      c->add(testData[i]);
    }
 
    reinterpret_cast<List *>(c)->sort();
 
    for (int i = 0; i < n; i++) {
      cout << (*reinterpret_cast<List *>(c))[i] << " ";
    }
 
    cout << endl;
 
    // not empty
    cout << (c->isEmpty() ? "true" : "false") << endl;
 
    for (int i = 0; i < n / 2; i++) {
      cout << "(" << (c->contain(i) ? "true" : "false");
      cout << ","
           << (reinterpret_cast<List *>(c)->indexOf(i) != -1 ? "true" : "false")
           << ") ";
      c->remove(i);
    }
 
    cout << endl;
 
    for (int i = 0; i < c->size(); i++) {
      cout << (*reinterpret_cast<List *>(c))[i] << " ";
    }
    cout << endl;
  }
 
  void test_ArrayList() {
    Collection *c = new ArrayList();
    test_List(c);
    delete c;
  }
 
  void test_LinkedList() {
    Collection *c = new LinkedList();
    test_List(c);
    delete c;
  }
 
  void runAllTests() {
    cout << "Testing ArrayList:" << endl;
    test_ArrayList();
    cout << endl;
    cout << "Testing LinkedList:" << endl;
    test_LinkedList();
  }
};
 
int main() {
  TEST t;
  t.runAllTests();
  return 0;
}



t617
关注
专栏目录
OOP.rar_C++_Z88D_bet5oq
09-24
**OOP.rar_C++_Z88D_bet5oq** 这个压缩包文件名暗示了其内容主要关于面向对象编程（Object-Oriented Programming, OOP）在C++语言中的应用，而“Z88D”可能是某种编译器、IDE或者调试工具的标识，而“bet5oq”可能...
[Inheritance]Collection with Inheritance (eden)
住在地球仪上的小刺猬的博客
07-12 391
下面我贴上题目：（英语渣渣觉得能坚持读完题目的人已经是勇士了）[Inheritance]Collection with Inheritance (eden)Knowledge pointsinheritance polymorphism virtual functions interface memory management dynamic castsIntroductionTrue objec...
继承练习题Collection with Inheritance
_Previous的博客
06-05 620
AssignmentAs we all know Java is a pure obejct oriented programming language and it also provide polymorphism.In JDK(1.7) architecture, java has its standar container classes. We can have a snapshot wi
[C++]D&A 5 Collection with Inheritance
stary_yan的博客
04-20 1197
D&A 5 Collection with Inheritance此题要求完成对以上类的实现。题目要求文件和答案知识点补充：虚继承虚继承 是面向对象编程中的一种技术，是指一个指定的基类，在继承体系结构中，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类。举例来说：假如类A和类B各自从类X派生（非虚继承且假设类X包含一些数据成员），且类C同时多继承自类A和B，那么C的对象就会拥有两套X的实例
inheritance5
04-08
抽象类方法 这个小项目是关于具有两个子类（自然人和公司）的一个人类。 Class Person是一个抽象类，名称为AnnualIncome，是一种称为tax的抽象方法。 班级自然人具有健康支出并扩展了班级人。 班级公司有员工人数，...
JAVA基础之继承（inheritance）详解
08-31
在Java面向对象编程（OOP）中，继承（Inheritance）是实现代码重用和抽象化的重要机制。它允许一个类（子类）从另一个类（超类、基类、父类）继承特性，包括方法和字段。继承使得子类能够获取父类的功能，同时还能...
Inheritance-Interfaces-Polymorphism:作业5
05-11
作业5 要求：•实施超类约会，并将子类“一次性”，“每日”和“每月”分别用于一次约会，每日约会和每月约会。 •约会有说明，年，月和日，例如，说明：请看牙医，年份：2018，月份：6，日期：6 •编写方法...
package-and-inheritance.zip_inheritance
09-24
5. **泛型**：泛型是一种强大的工具，用于在编译时检查类型安全，并减少类型转换的需要。它可以应用于类、接口和方法，限制可以存储在集合中的对象类型。 6. **JVM**：Java虚拟机（JVM）是Java程序运行的平台，它...
线性同余法取随机数
热门推荐
t617的博客
07-01 1万+
线性同余法求伪随机数，Linear-Congruential: (a * x + c) % m, a > 0, m > 0, m % a 首先，说明一下取随机数一般会用rand函数，取time.h文件中的clock()作为种子，产生我们需要的随机数 #include #include //srand()、rand() #include //time(); int mai
寻找第k大数字
t617的博客
12-10 2276
1003. 寻找第k大数字(numberk)
sicily 简单哈希
t617的博客
12-14 1293
sicily 1004. 简单哈希 原题： Description  使用链地址法（又称拉链法）可以解决Hash中的冲突问题。其基本思想是：将具有相同哈希地址的记录链成一个单链表，m个哈希地址就设m个单链表，然后用一个数组将m个单链表的表头指针存储起来，形成一个动态的结构（图1）。   现在给定哈希函数为Hash(key)= key mod 13，要求使用链地址法处理冲突，设有冲突的元素均插入表尾。要
STL bitset题目
t617的博客
05-26 1149
Give you N numbers a[1]...a[n] and M numbers b[1]...b[m] For each b[k], if we can find i,j  a[i] + a[j] = b[k] or a[i] = b[k] , we say k is a good number. And you should only output the number of g
AVL Tree
t617的博客
12-10 994
sicily 1005. AVL Tree 给出结点的插入序列，构造AVL Tree。
string类大小写转换
t617的博客
05-17 988
经常遇到字符串类型大小写转换，下面用两种方法实现： 1. tolower / toupper--头文件 #include #include #include #include using std::cin; using std::cout; using std::endl; using std::string; using std::set; using std::vector; int
简单括号匹配
t617的博客
12-30 845
Description 检查输入字符串中的括号是否匹配。括号包括：{, }, (, ), [, ].   Input 第一行是一整数，即测试样例个数n. 以下n行，每一行是一个长度不超过100个字符的字符串。   Output 匹配成功输出Yes，否则输出No,每个输出加换行。   Sample Input 4 a 2-[(1+2)*2] (a+b
Floyd算法求最短路径
t617的博客
12-12 813
Floyd算法 算法思想 通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。 算法过程 1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。 2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。 把图用邻接矩阵G表示出来，如果从Vi
Dijkstra's 算法
t617的博客
12-08 675
迪杰斯特拉算法 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 原理： 1.首先，引入一个辅助向量D，它的每个分量 D    表示当前所找到的 Dijkstra算法运行动画过程 从起始
Date类实现
t617的博客
08-31 671
要实现一个简单的Date类不是很难，下面简单实现Date的一些基本用处： 要求： #ifndef DATE_H #define DATE_H #include #include class Date { public: /** * @brief default constructor */ Date(); /** * @brief constructor wi
最小生成树Prim算法
t617的博客
12-08 665
最小生成树 最小生成树可以用kruskal（克鲁斯卡尔）算法或prim（普里姆）算法求出。 Prim算法简述 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew= {x}，其中x为集合V中的任一节点（起始点），Enew=
a has-a relationship is implemented via inheritance.
最新发布
01-06
“拥有-关系”是通过继承来实现的。在面向对象编程中，当一个类拥有另一个类的对象作为其成员变量时，就可以称之为"拥有-关系"。这种关系可以通过继承来实现，即一个类可以继承另一个类，并在子类中拥有父类的对象。 例如，我们有一个动物类Animal和一个狗类Dog。狗是动物的一种，所以狗类可以继承动物类。在狗类中，我们可以定义一个成员变量来存储狗的名字、年龄等信息，并将其作为动物的一部分。这样，狗类就拥有了动物类的特性和行为，而且可以在其基础上进行扩展和修改。 通过继承，狗类可以重用动物类的代码，而不需要重新编写。这样可以提高代码的复用性和可维护性。同时，动物类可以作为基类，定义一些通用的属性和方法，而狗类可以作为派生类，在其基础上添加一些特有的属性和方法。这样就可以实现代码的扩展和灵活性。 总之，"拥有-关系"通过继承来实现，可以帮助我们实现代码的复用和扩展，提高程序的可维护性和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值