技術標籤：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;
}