array 类模板(检测边界,自动排序)

最新推荐文章于 2023-05-13 14:37:32 发布
最新推荐文章于 2023-05-13 14:37:32 发布
阅读量1k 收藏
点赞数
分类专栏： C/C++ 文章标签： iterator class instantiation os delete iostream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lonelyforest/article/details/392434
版权

/************************    ArrayBase.h  ********************
 **************************公共基类
 * Copyright (c) 2004  L.F Studio
 *
 * E-mail: lonelyforest@126.com  OICQ: 36274668
 *
 ***************************************************************/
 
#ifndef AYYAY_BASE_H
#define AYYAY_BASE_H
 
#include <ostream>
using namespace std;

 
 template<class elemType>
 class Array;
 
 template<class elemType>
 ostream &operator<<(ostream &os, const Array<elemType> &Aobj)
 {
 return Aobj.print( os );
}
   
 
 template< class elemType>
 class Array{
  public:
   explicit Array(int sz = ArraySize)
   {  init(0, sz); }
   
   Array(const elemType *ar = 0, int sz)
   {  init(ar, sz); }
   
   Array(const Array<elemType> &Aobj)
   {   init(Aobj._ia, Aobj._size); }
   
   virtual ~Array() { delete [] _ia; }
   
 //------------class--iterator----------------------------------
   class iterator{
    public:
     iterator() { _loc = 0; }
     
     iterator(elemType *p) { _loc = p; }
     
     iterator &operator++() {
      _loc++;
      return *this;
     }
     
     const elemType &operator*() {
      if ( !_loc)
      {
       throw "iterator: pointer not initialized";
      }
      
      return *_loc;
     }
     
     bool operator==(const iterator &b) {
      return _loc == b._loc;
     }
     
     bool operator!=(const iterator &b) {
      return _loc != b._loc;
     }
     
    protected:
     elemType *_loc;
    };

 //--------------class---iterator--end-------------------
 
  virtual ostream &print( ostream & ) const;
  virtual void grow();
  virtual elemType    min() const;
  virtual elemType    max() const;
  virtual int find( const elemType &val ) const;
  virtual void sort(int first = 0, int last);
   
  elemType at( int ix ) const { return _ia[ix]; }
  Array &operator=(const Array &);
   
  virtual elemType &operator[](int ix) const
  {  return _ia[ix]; }
   
  int size() { return _size; }
   
   //friend;
   friend ostream &operator<<<>(ostream &os,
          const Array<elemType> &Aobj);
   
   iterator begin()
   {
    return iterator (_ia);
   }
   
   iterator end()
   {
    return iterator(_ia + _size);
   }
   
   
 protected:
   void init(const elemType *, int);
   void swap(int, int);
   static  const int ArraySize = 12;
   
   int _size;
   elemType *_ia;
   
};
 
#endif

#ifdef  AYYAY_BASE_H
#include "ArrayBase.cpp"
#endif
 
 
/*****************   ArrayBase.cpp  **************************
 *************************************************************
 * E-mail: lonelyforest@126.com  OICQ: 36274668
 *************************************************************/


#ifndef ARRAY_BASE_CPP
#define ARRAY_BASE_CPP

#include <ostream>

template < class elemType >
ostream &Array< elemType >::print( ostream &os) const
{
 const int lineSize = 10;

 os << "( " << _size << " ) <";

 for ( int ix = 0; ix < _size; ++ix)
 {

  if((ix%lineSize) == 0 && ix != 0 )
  {
   os << "/n/t";
  }

  os << _ia[ix];

  if (((ix % lineSize) != lineSize -1) && (ix < _size - 1))
  {
   os << ", ";
  }
 }

 os << " >/n";
 return os;
}

template < class elemType >
void Array< elemType >::grow()
{
 elemType *oldia = _ia;
 int oldSize = _size;

 _size = oldSize + oldSize/2 + 1;
 _ia = new elemType[_size];

 int ix = 0;
 for (; ix < oldSize; ++ix)
 {
  _ia[ix] = oldia[ix];
 }

 for (; ix < _size; ++ix)
 {
  _ia[ix] = elemType();
 }

 delete[] oldia;
}

template < class elemType >
void Array< elemType >::init(const elemType *array, int sz)
{
 _size = sz;
 _ia = new elemType[_size];
 
 for ( int ix = 0; ix < _size; ++ix)
 {
  if ( array )
  {
            _ia[ix] = array[ix];
  }
  else
  {
   _ia[ix] = ix;
  }
 }
}

template <class elemType>
elemType    Array< elemType >::min() const
{
 assert( _ia != 0 );
 elemType    min_val  = _ia[0];
 for ( int ix = 1; ix < _size; ++ix ){
  if ( _ia[ix] < min_val )
      min_val = _ia[ix];
 }

 return  min_val;
}

template < class elemType>
elemType    Array< elemType >::max() const
{
 assert( _ia != 0 );
 elemType    max_val = _ia[0];
 for ( int   ix = 1; ix < _size; ++ix )
 {
  if ( _ia[ix] > max_val )
      max_val = _ia[ix];
 }

 return max_val;
}

template < class elemType >
int    Array< elemType >::find(const elemType &val)  const
{
 for ( int ix = 0; ix < _size; ++ix )
     if (val == _ia[ix] )    return ix;

 return -1;
}

//===============quick sort====================================
template < class elemType >                             //=====
void    Array< elemType >::sort( int first, int last )  //=====
{                                                       //=====
 if ( first >= last )   return;                      //=====
                                                     //=====
 int low = first;                                    //=====
 int high = last + 1;                               //=====
                                                     //=====
 elemType elem = _ia[low];                           //=====
              //=====
 for (;;) {                                          //=====
  while ( _ia[++low] < elem && low < last );      //=====
  while ( _ia[--high] > elem && high > first );   //=====
  if ( low < high )                               //=====
      swap( low, high );                          //=====
  else break;                                     //=====
 }                                                   //=====
              //=====
  swap( first, high );                                //-----
 sort( first, high - 1 );                            //-----
 sort( high+1, last);                                //-----
              //-----
}                                                       //-----
//=================quick sort==================================

template < class elemType >
void Array< elemType >::swap(int i, int j)
{
 elemType    tmp = _ia[i];
 _ia[i] = _ia[j];
 _ia[j] = tmp;
}

template < class elemType >
Array< elemType >  &Array< elemType >::
operator=( const Array< elemType > &Aobj)
{
 if ( this != &Aobj )
 {
    delete[] _ia;
   init( Aobj._ia, Aobj._size);
 }

   return *this;
}

#endif

/*******************  Array_RC.h     **********************
 ***********检测边界的array
 **********************************************************/
#ifndef ARRAY_RC_H
#define ARRAY_RC_H

#include "ArrayBase.h"

template <class Type>
class Array_RC : public virtual Array<Type> {
 public:
  Array_RC( int sz = Array<Type>::ArraySize )
          : Array<Type>( sz ) {}

  Array_RC( const Array_RC& r );
  Array_RC( const Type *ar, int sz );
  Type& operator[](int ix );
};

#include "Array_RC.cpp"
#endif


/************   Array_RC.cpp   ******************
 *
 *******************************************************/

//---------define the Array_RC.h as ARRAY_RC_CPP---
#ifndef ARRAY_RC_CPP
#define ARRAY_RC_CPP

#include <assert.h>

template < class Type >
Array_RC< Type >::
Array_RC( const Array_RC< Type > &r)
  : Array<Type>( r ) {}
  
template < class Type >
Array_RC< Type >::
Array_RC( const Type *ar, int sz )
  : Array<Type>(ar, sz ) {}
  
template < class Type >
Type &Array_RC< Type >::operator[]( int ix )
{
 assert( ix >= 0 && ix < Array<Type>::_size );
 return  Array<Type>::_ia[ix];
}

#endif


/***************   Array_Sort.h  **********自动排序的array
 *********************************************************/

#ifndef ARRAY_SORT_H
#define ARRAY_SORT_H

#include "ArrayBase.h"

#include <iostream>
using namespace std;

template <class Type>
class Array_Sort : public virtual Array<Type> {
 protected:
  void set_bit() { dirty_bit = true; }
  void clear_bit() { dirty_bit = false; }
  void check_bit() {
   if ( dirty_bit ) {
    Array<Type>::sort(0, Array<Type>::_size - 1);
    clear_bit();
   }
  }
  
 public:
  Array_Sort(int sz = Array<Type>::ArraySize)
    : Array<Type>(sz)
  {
   clear_bit();
  }
  
  Array_Sort(const Array_Sort& );
  Array_Sort(const Type *arr, int sz )
      : Array<Type>(arr, sz)
  {
   Array<Type >::sort(0, Array<Type>::_size - 1);
   clear_bit();
  }
  
  Type& operator[]( int ix )
  { set_bit(); return Array<Type>::_ia[ix]; }
  
 virtual void print(ostream& os = cout )
  {
   check_bit();
   Array<Type>::print( os );
  }
  
 inline Type& min()
  {
   check_bit();
   return Array<Type>::_ia[0];
  }
  
 inline Type& max()
  {
   check_bit();
   return Array<Type>::_ia[Array<Type>::_size - 1 ];
  }
  
 inline bool is_dirty() const
  {
   return dirty_bit;
  }
  
  int find( Type& );
  void grow();
 protected:
  bool dirty_bit;
};

 

#include "Array_Sort.cpp"
#endif

 

/****************   Array_Srot.cpp   ************************
 ***********************************************************/

#ifndef ARRAY_SORT_CPP
#define ARRAY_SORT_CPP

template < class Type >
Array_Sort< Type >::
Array_Sort( const Array_Sort<Type > &as )
 : Array< Type >( as )
{
 dirty_bit = as.dirty_bit;
 check_bit();
}

template < class Type >
void Array_Sort< Type >::grow()
{
 Array<Type>::grow();
 Array<Type>::sort(0, Array<Type>::_size - 1);
 clear_bit();
}

template < class Type >
int Array_Sort< Type >::find( Type& val)
{
 int low = 0;
 int high = Array<Type>::_size-1;
 check_bit();
 
 while ( low <= high ) {
  int mid = ( low + high ) / 2;
  if ( val == Array<Type>::_ia[mid] )  return mid;
  if ( val < Array<Type>::_ia[mid] )
  {
   high = mid - 1;
  }
  else
  {
   low = mid + 1;
  }
 }
 
 return -1;
}

 


#endif

 

/**********   Array.h   *********************
 ***********检测边界，自动排序的array
 *********************************************/
#ifndef ARRAY_RC_S_H
#define ARRAY_RC_S_H

#include "Array_RC.h"
#include "Array_Sort.h"

template< class Type >
class ARRAY : public virtual Array_RC< Type >,
     public virtual Array_Sort< Type >
{
public:
 ARRAY(int sz = Array<Type>::Arraysize )
     : Array<Type>( sz )
 {
  Array_Sort<Type>::clear_bit();
 }

 ARRAY( const ARRAY &rca )
     : Array<Type>( rca )
 {
  Array<Type>::sort( 0, Array<Type>::_size-1);
  Array_Sort<Type>::clear_bit();
 }

 ARRAY( Type *arr, int sz )
     : Array<Type>(arr, sz )
 {
  Array<Type>::sort(0, Array<Type>::_size-1);
  Array_Sort<Type>::clear_bit();
 }

 Type& operator[]( int ix )
 {
  Array_Sort<Type>::set_bit();
  return Array_RC<Type>::operator[](ix);
 }
 
 virtual void print( ostream& os = cout )
 {
  Array_Sort<Type>::print(os);
 }

};


#endif


/*******************   try_array.cpp  ********************

****array 测试函数
 **********************************************************/
 
#include "Array.h"

template <class elemType>
 void    try_array( ARRAY< elemType > &iA)
{

 cout << "try_array: initial array values:/n";
 cout << iA << endl;
 
 elemType    find_val    = iA[iA.size() - 1 ];
 iA[iA.size() - 1 ] = iA.min();
 
 int mid = iA.size() / 2;
 iA[0] = iA.max();
 iA[mid] = iA[0];
 cout << "try_array: after assignments:/n";
 cout << iA << endl;
 
 ARRAY< elemType > iA2 = iA;
 iA2[mid/2] = iA2[mid];
 cout << "try_array: memberwise initializetion/n";
 cout << iA << endl;
 
 iA = iA2;
 cout << "try_array: after memberwise copy/n";
 cout << iA << endl;
 
 iA.grow();
 cout << "try_array: after grow/n";
 cout << iA << endl;
 int index = iA.find(find_val);
 cout << "value to find:" << find_val;
 cout << "/tindex returned: " << index << endl;
 
 elemType value = iA[index];
 cout << "value found at index: ";
 cout << value << endl;
}


//----------------------array_test.cpp (main) -----------------------

#include "MyHeader/try_array.cpp"  // All header stored in MyHeader
#include "MyHeader/ARRAY.h"

#include <cstdlib>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
 cout << "try array begin.../n";

 static int ia[10] = {12, 7, 14, 9, 128, 17, 6, 3, 27, 5};
 static string sa[7] = { "Eeyore", "Pooh", "Tigger", "Piglet",
                     "Owl", "Gopher", "Heffalump" };

 ARRAY< int >  iA( ia, 10 );
 ARRAY< string > SA( sa, 7 );

  cout << "class template instantiation ARRAY<int >/n";
 //try_array(iA);

 cout << "class template instantiation ARRAY<string> /n";
 try_array(SA);

    system("PAUSE");
    return EXIT_SUCCESS;
}

lonelyforest
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Array.h数组模板
IT_JS_tao的博客
12-02 1455
模板快速了解
c++ array模板类使用
热门推荐
我的博客
08-10 6万+
目录 1、array模板类的定义 （1）array模板类的声明 （2）容器属性 （3）array模板类的说明 （4）array模板类头文件 2、array模板类的使用 （1）Iterators （2）Capacity （3）Element access （4）Modifiers （5）Compare （6）Other 本章是对c++ array模板类的知识归纳，讲述了c+...
Array模板类
PlihuoHitilan的专栏
03-07 950
模板类算是比较麻烦的一个东西，在这儿我记一个我自己写的模板Array类：   #include #include #include"Array.h" #include"outOfRange.h" using namespace std; template class Array { friend ostream& operator& temp) {
模板类array
weixin_43213895的博客
10-04 461
与数组一样，array对象的长度也是固定的，也使用栈（静态内存分配），而不是自由存储区，因此其效率与数组相同，但更方便，更安全。要创建array对象，需要包含头文件array。array对象的创建语法与vector稍有不同： #include <array> using namespace std; array<int,5> ai; array <double,4> ad={1.2,31.4,1.4,1.5,1.6}; 参考： C++array模板类的使用 ...
模板类实现数组类封装模板类实现数组类封装
03-01
为了解决这些问题，我们可以创建一个模板类`Array`，它将数组作为内部实现，但对外提供一个更友好的接口。模板类允许我们在实例化时指定元素的类型，这样我们就可以处理任何类型的数据，如整数、浮点数、自定义对象...
CP模板：我的竞争编程模板
02-11
动态规划模板通常包括状态定义、转移方程、边界条件等，是解决复杂问题的常见方法。 6. **图论**： 图的表示（邻接矩阵、邻接表）和搜索算法（深度优先搜索DFS、广度优先搜索BFS）是图论问题的基础。可能还包括...
quicksort:按升序和降序快速排序
06-26
在JavaScript中实现快速排序，可以使用以下代码模板： ```javascript function quickSort(arr, left = 0, right = arr.length - 1) { if (left ) { const pivotIndex = partition(arr, left, right); quickSort...
C++实现选择排序算法
08-18
在C++中实现选择排序，我们可以使用标准模板库（STL）中的`algorithm`头文件，但为了更好地理解排序过程，通常我们会自定义函数来实现。 下面将详细介绍如何用C++实现选择排序算法： 1. **算法步骤**： - 初始化...
array_synthesis:基本数组处理算法的综合
04-30
"array_synthesis"项目，从其标题来看，主要是关于基本数组处理算法的综合应用，这通常涉及一系列操作，如搜索、排序、过滤、统计等。在C++这种面向对象的语言中，理解并熟练运用这些算法对于提升程序性能至关重要。...
60、数组类模板
xiebs的博客
09-17 716
1、预备知识 模板参数可以是数值型参数（非类型参数） template < typename T, int N > void func() { T a[N]; //使用模板参数定义局部数组 } func<float, 10>(); 数值型模板参数的限制 — 变量不能作为模板参数 — 浮点数不能作为模板参数 — 类对象不能作为模板参数 — … 本质：模......
1874 模板类Array
a1838770953的博客
10-13 469
肇砖oj题，仅供参考，不怕被钟sir封号三周你就抄
C++作业 9 - 1（array类模板的使用）
qq_41579591的博客
05-01 858
#include <array> #include<bits/stdc++.h> using namespace std; const int N = 1e5 + 10; int main() { int n; cin >> n; array<double, N> arr{}; double t; int i = 0; for (auto &e : arr) { cin &g.
详解c++---array和模板
最新发布
qq_68695298的博客
05-13 1807
array的介绍和模板的一些特性
C++采用模板技术设计动态数组类 Array
qmyxhs的博客
05-19 1687
题目要求： 类模板成员包括：数组长度、元素个数、数据指针。 （3）通过构造函数创建数组默认包含10个元素，通过析构函数释放数组数据。 （4）添加数组元素：int AddItem(T aData); 返回类型为添加元素的下标号，如果数组长度不够，需要动态扩展。 （5）删除数据元素：bool RemoveAt(int index); 返回是否删除成功。 （6）插入数组元素 void InsertItem( int index, T aData); 在数组的第index的位置插入元素aData。 （7）数组元素
c++ array 模板类使用
digitalkee的博客
06-24 1219
目录 1、array模板类的定义 （1）array模板类的声明 （2）容器属性 （3）array模板类的说明 （4）array模板类头文件 2、array模板类的使用 （1）Iterators （2）Capacity （3）Element access （4）Modifiers （5）Compare （6）Other 本章是对c++ array模板类的知识归纳，讲述了c++中array模板类的使用，不涉及原理方面的内容。 c++中的数组类型是继承了c语言的特性，在使用数组的时候要
CentOS 下安装Eigen库
白水的博客
09-02 3937
1. 下载并按照Eigen库 首先打开Eigen官网（https://eigen.tuxfamily.org/index.php）。找到合适的Eigen版本，右键点击tar.gz压缩包，点击复制链接。如下例图 之后在CentOS终端粘贴，下载Eigen文件： wget https://gitlab.com/libeigen/eigen/-/archive/3.3.9/eigen-3.3.9.tar.gz 下载完成后解压： tar -zxvf eigen-3.3.9.tar.gz 然后打开解压的目录：
编写一个使用数组类模板Array对数组进行排序、求最大值和求元素和的程序，并采用相关数据进行测试。
u012653518的专栏
12-08 9532
#include using namespace std; template class Array{ private: T *elem; int size; public: Array(int a[],int s):elem(a),size(s){} T Max(); T Sum(); void Sort(); void Display(); };   templa
C++模板深入解析：Array类模板实例与标准库
当我们声明如`Array<int> ia(array_size)`这样的对象时，编译器会为`Array`类模板创建一个特定于`int`类型的实例。类模板的成员变量和函数也会根据指定的类型进行调整。例如，对于`Array<int>`，编译器会生成一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值