动态数组 C实现&C++实现
1:分别使用C和C++语言实现一个长度可扩充的数组(包含必要的数据结构及函数)。
2:要求能存放int类型的数据。
所实现的数组结构包含以下接口(操作):
- array_initial: 对数组结构进行初始化
- array_capacity: 返回数组结构的容量
- array_size: 返回数组结构包含的元素个数
- array_recap: 重新对数组结构申请空间
- array_at: 返回对应位置的元素(的引用)
- array_append: 在数组结构后面加入一个元素
- array_insert: 在数组结构给定的位置插入一个元素
- array_copy: 复制一个数组结构到另一个数组结构
- array_compare: 比较两个数组结构是否相同,这里的相同是指里面的元素相同
- array_destroy: 销毁一个数组结构
C实现:
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <assert.h>
typedef struct
{
int size;//容量
int count;//元素个数
int *data;//数据
} CArray;
//对数组结构进行初始化
void array_initial(CArray &array)
{
array.count=0;
array.size=0;
array.data=NULL;
}
//返回数组结构的容量
inline int array_capacity(CArray &array)
{
return array.size;
}
//返回数组结构包含的元素个数
inline int array_size(CArray &array)
{
return array.count;
}
//重新对数组结构申请空间
void array_recap(CArray &array, int capacity)
{
if(capacity!=array.size)
{
int *data=(int*)malloc(sizeof(int)*capacity);
if(data!=NULL)
{
for(int i=0;i<array.count;i++)
data[i]=array.data[i];
}
free(array.data);
array.data=data;
array.size=capacity;
}
}
//返回对应位置的元素(的引用)
inline int &array_at(CArray &array, int index)
{
return *(array.data+index);
}
//在数组结构后面加入一个元素
void array_append(CArray &array, int element)
{
if(array.count==array.size)
{
array_recap(array, array.size+1);
}
array.data[array.count]=element;
array.count++;
}
//在数组结构给定的位置插入一个元素
void array_insert(CArray &array, int index, int element)
{
if(index>array.count)
printf("index error");
else
{
if(array.count>=array.size)
array_recap(array, array.size+1);
for(int i=array.count;i>index;i--)
{
array.data[i]=array.data[i-1];
}
array.data[index]=element;
array.count++;
}
}
//复制一个数组结构到另一个数组结构
void array_copy(CArray &src, CArray &dst)
{
dst.count=src.count;
dst.size=src.size;
dst.data=(int*)malloc(sizeof(int)*src.size);
for(int i=0;i<src.count;i++)
{
dst.data[i]=src.data[i];
}
}
//比较两个数组结构是否相同,这里的相同是指里面的元素相同
bool array_compare(CArray &array1, CArray &array2)
{
int i;
if(array1.count==array2.count)
{
for(i=0;i<array1.count;i++)
{
if(array1.data[i]!=array2.data[i])
return false;
}
return true;
}
else
return false;
}
//销毁一个数组结构
void array_destroy(CArray &array)
{
array.count=0;
array.size=0;
free(array.data);
array.data=NULL;
}
C++实现
#include <memory.h>
#include <iostream>
#include <assert.h>
class CArray
{
public:
typedef int Element;
public:
CArray();
~CArray();
int capacity() const;
int size() const;
void recap(int capacity);
Element &at(int index);
Element at(int index) const;
void append(Element element);
void insert(int index, Element element);
void copy(const CArray &rhs);
bool compare(const CArray &rhs) const;
private:
/*data*/
int *m_buff;
int m_size;//数据结构的元素个数
int m_capacity;//数组结构的容量
};
CArray::CArray()
{
m_buff=NULL;
m_size=0;
m_capacity=0;
}
CArray::~CArray()
{
if (m_buff != NULL)
delete[] m_buff;
m_buff = NULL;
m_capacity = 0;
m_size = 0;
}
int CArray::capacity() const
{
return m_capacity;
}
int CArray::size() const
{
return m_size;
}
void CArray::recap(int capacity)
{
if (capacity == m_capacity)
{
return;
}
int *buff = new int[capacity];
m_capacity = capacity;
m_size = capacity < m_size ? capacity : m_size;
memcpy(buff, m_buff, m_size * sizeof(int));
delete[] m_buff;
m_buff = buff;
}
CArray::Element &CArray::at(int index)
{
Element &temp=m_buff[index];
return temp;
}
CArray::Element CArray::at(int index) const
{
return this->m_buff[index];
}
void CArray::append(Element element)
{
if(m_size == m_capacity)
recap(m_capacity+1);
m_buff[m_size++] = element;
}
void CArray::insert(int index, Element element)
{
if(m_size == m_capacity)
recap(m_capacity+1);
for (int i = m_size; i > index; --i)
{
m_buff[i] = m_buff[i - 1];
}
m_buff[index] = element;
m_size += 1;
}
void CArray::copy(const CArray &rhs)
{
if(m_capacity < rhs.m_capacity)
recap(rhs.m_capacity);
memcpy(m_buff, rhs.m_buff, rhs.m_size * sizeof(int));
m_size = rhs.m_size;
}
bool CArray::compare(const CArray &rhs) const
{
if (rhs.m_size != m_size)
{
return false;
}
return memcmp(m_buff, rhs.m_buff, m_size) == 0;
}
调试代码
int main(int argc, char *argv[])
{
CArray array;
// 不再需要initial,但应该有正确的初始化
// array_initial(array);
array.recap(10);
assert(array.capacity() == 10);
//
for (int i = 0; i < 20; ++i)
{
array.append(i);
}
assert(array.size() == 20);
for (int i = 0; i < array.size(); ++i)
{
assert(array.at(i) == i);
}
//
CArray array2, array3;
// array_initial(array2);
// array_initial(array3);
array2.copy(array);
assert(array.compare(array2) == true);
array3.copy(array);
assert(array.compare(array3) == true);
//
array2.insert(2, 3);
assert(array.compare(array2) == false);
//
array3.at(2) = 5;
assert(array.compare(array3) == false);
//
// 不再需要destroy,但应该有正确的内存释放
// array_destroy(array);
// array_destroy(array2);
// array_destroy(array3);
return 0;
}