动态数组 C实现 C++实现

动态数组 C实现&C++实现

1：分别使用C和C++语言实现一个长度可扩充的数组（包含必要的数据结构及函数）。
2：要求能存放int类型的数据。

所实现的数组结构包含以下接口（操作）：

1. array_initial: 对数组结构进行初始化
2. array_capacity: 返回数组结构的容量
3. array_size: 返回数组结构包含的元素个数
4. array_recap: 重新对数组结构申请空间
5. array_at: 返回对应位置的元素(的引用)
6. array_append: 在数组结构后面加入一个元素
7. array_insert: 在数组结构给定的位置插入一个元素
8. array_copy: 复制一个数组结构到另一个数组结构
9. array_compare: 比较两个数组结构是否相同，这里的相同是指里面的元素相同
10. 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;
}