hyzboy/CMCore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adjust int to int64 in many templates.

Browse Source
This commit is contained in:
hyzboy 2024-03-09 19:47:26 +08:00
parent f2519a16be
commit d63fb86ebd
5 changed files with 159 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
inc/hgl/type/AccumMemoryManager.h Normal file
View File

@ -0,0 +1,64 @@
#pragma once
#include<hgl/type/DataArray.h>
namespace hgl
{
/**
* 累计内存管理<br>
* 用于不断分配固定容量的内存块，但不动态调整，最后统一释放的情况。
*/
class AccumMemoryManager
{
public:
struct Block
{
int64 offset;
int64 size;
};
private:
int64 total_bytes=0; ///<总字节数
DataArray<AccumMemoryManager::Block> block_list;
DataArray<char> data_array; ///<数据
public:
AccumMemoryManager()=default;
~AccumMemoryManager()=default;
const int64 GetTotalBytes()const{return total_bytes;}
const int64 GetBlockCount()const{return block_list.GetCount();}
const void *Acquire(const int64 size)
{
if(size<=0)return(nullptr);
Block b;
b.offset=total_bytes;
b.size=size;
data_array.AddCount(size);
return data_array.GetPointer(b.offset);
}
void Clear()
{
total_bytes=0;
block_list.Clear();
data_array.Clear();
}
void Free()
{
total_bytes=0;
block_list.Free();
data_array.Free();
}
};//class AccumMemoryManager
}//namespace

22
inc/hgl/type/ArrayItemProcess.h
View File

@ -35,14 +35,14 @@ namespace hgl
/** /**
* 查找数据在无序阵列中的位置 * 查找数据在无序阵列中的位置
*/ */
template<typename T> static int FindDataPositionInArray(const T *data_list,const int count,const T &data) template<typename T> static int FindDataPositionInArray(const T *data_list,const int64 count,const T &data)
{ {
if(!data_list)return(-1); if(!data_list)return(-1);
if(count<=0)return(-1); if(count<=0)return(-1);
const T *p=data_list; const T *p=data_list;
for(int i=0;i<count;i++) for(int64 i=0;i<count;i++)
{ {
//if(*p==data) //if(*p==data)
if(!memcmp(p,&data,sizeof(T))) if(!memcmp(p,&data,sizeof(T)))
@ -54,7 +54,7 @@ namespace hgl
return -1; return -1;
} }
template<typename T,typename O> static int FindDataPositionInArray(const T &data_list,const O &data) template<typename T,typename O> static int64 FindDataPositionInArray(const T &data_list,const O &data)
{ {
return FindDataPositionInArray(data_list.GetData(),data_list.GetCount(),data); return FindDataPositionInArray(data_list.GetData(),data_list.GetCount(),data);
} }
@ -62,10 +62,10 @@ namespace hgl
/** /**
* 查找数据在有序阵列中的位置 * 查找数据在有序阵列中的位置
*/ */
template<typename T> static int FindDataPositionInSortedArray(const T *data_array,const int count,const T &flag) template<typename T> static int64 FindDataPositionInSortedArray(const T *data_array,const int64 count,const T &flag)
{ {
int left=0,right=count-1; //使用left,right而不使用min,max是为了让代码能够更好的阅读。 int64 left=0,right=count-1; //使用left,right而不使用min,max是为了让代码能够更好的阅读。
int mid; int64 mid;
while(left<=right) while(left<=right)
{ {
@ -91,7 +91,7 @@ namespace hgl
return(-1); return(-1);
} }
template<typename T,typename O> static int FindDataPositionInSortedArray(const T &data_array,const O &flag) template<typename T,typename O> static int64 FindDataPositionInSortedArray(const T &data_array,const O &flag)
{ {
return FindDataPositionInSortedArray(data_array.GetData(),data_array.GetCount(),flag); return FindDataPositionInSortedArray(data_array.GetData(),data_array.GetCount(),flag);
} }
@ -104,10 +104,10 @@ namespace hgl
* @param flag 要查找的数据 * @param flag 要查找的数据
* @return 这个数据是否已经存在 * @return 这个数据是否已经存在
*/ */
template<typename T> static bool FindInsertPositionInSortedArray(int *pos,const T *data_array,const int count,const T &flag) template<typename T> static bool FindInsertPositionInSortedArray(int64 *pos,const T *data_array,const int64 count,const T &flag)
{ {
int left=0,right=count-1; int64 left=0,right=count-1;
int mid; int64 mid;
while(left<=right) while(left<=right)
{ {
@ -182,7 +182,7 @@ namespace hgl
return(false); return(false);
} }
template<typename T,typename O> static bool FindInsertPositionInSortedArray(int *pos,const T &data_array,const O &flag) template<typename T,typename O> static bool FindInsertPositionInSortedArray(int64 *pos,const T &data_array,const O &flag)
{ {
return FindInsertPositionInSortedArray(pos,data_array.GetData(),data_array.GetCount(),flag); return FindInsertPositionInSortedArray(pos,data_array.GetData(),data_array.GetCount(),flag);
} }

39
inc/hgl/type/ArrayRearrangeHelper.h
View File

@ -8,24 +8,24 @@ namespace hgl
*/ */
class ArrayRearrangeHelper class ArrayRearrangeHelper
{ {
int data_count; ///<数据总量 int64 data_count; ///<数据总量
int left_count; ///<剩余数量 int64 left_count; ///<剩余数量
int data_offset; ///<当前访问偏移 int64 data_offset; ///<当前访问偏移
int field_count; //分段数量 int64 field_count; ///<分段数量
struct Field struct Field
{ {
int start; int64 start;
int count; int64 count;
}; };
Field *field_list; Field *field_list;
int field_index; int64 field_index;
public: public:
ArrayRearrangeHelper(int dc,int fc) ArrayRearrangeHelper(int64 dc,int64 fc)
{ {
data_count=dc; data_count=dc;
left_count=dc; left_count=dc;
@ -45,7 +45,7 @@ namespace hgl
/** /**
* 添加一个分段 * 添加一个分段
*/ */
bool AddField(int count) bool AddField(int64 count)
{ {
if(count<0)return(false); if(count<0)return(false);
if(count>left_count)return(false); if(count>left_count)return(false);
@ -63,9 +63,9 @@ namespace hgl
/** /**
* 添加多个分段 * 添加多个分段
*/ */
bool AddField(const std::initializer_list<int> &count_list) bool AddField(const std::initializer_list<int64> &count_list)
{ {
for(const int count:count_list) for(const int64 count:count_list)
if(!AddField(count)) if(!AddField(count))
return(false); return(false);
@ -100,7 +100,7 @@ namespace hgl
* 重新排列数据到一个新的数组中 * 重新排列数据到一个新的数组中
*/ */
template<typename T> template<typename T>
bool Rearrange(T *new_array,const T *old_array,const int *index) bool Rearrange(T *new_array,const T *old_array,const int64 *index)
{ {
if(!Finish()) if(!Finish())
return(false); return(false);
@ -108,7 +108,7 @@ namespace hgl
T *p=new_array; T *p=new_array;
Field *f; Field *f;
for(int i=0;i<field_index;i++) for(int64 i=0;i<field_index;i++)
{ {
if(*index<0||*index>=field_index) if(*index<0||*index>=field_index)
return(false); return(false);
@ -125,20 +125,23 @@ namespace hgl
} }
template<typename T> template<typename T>
bool Rearrange(T *new_array,const T *old_array,const std::initializer_list<int> &index) bool Rearrange(T *new_array,const T *old_array,const std::initializer_list<int64> &index)
{ {
return Rearrange(new_array,old_array,index.begin()); return Rearrange(new_array,old_array,index.begin());
} }
};//class ArrayRearrangeHelper };//class ArrayRearrangeHelper
template<typename T> template<typename T>
inline bool ArrayRearrange(T *new_array,const T *old_array,const int count,const std::initializer_list<int> &field_list,const std::initializer_list<int> &index) inline bool ArrayRearrange( T *new_array,
const T *old_array,const int64 count,
const std::initializer_list<int64> &field_list,
const std::initializer_list<int64> &index)
{ {
int field_count=(int)field_list.size(); int64 field_count=(int)field_list.size();
int total=0; int64 total=0;
for(const int fc:field_list)total+=fc; for(const int64 fc:field_list)total+=fc;
if(total<count) if(total<count)
++field_count; ++field_count;

88
inc/hgl/type/DataArray.h
View File

@ -13,15 +13,15 @@ namespace hgl
protected: protected:
T *items; T *items;
int count; ///<当前数据数量 int64 count; ///<当前数据数量
int alloc_count; ///<已分配的数据数量 int64 alloc_count; ///<已分配的数据数量
public: public:
int GetCount ()const{return count;} ///<取得数据数量(注：非字节数) int64 GetCount ()const{return count;} ///<取得数据数量(注：非字节数)
const int GetAllocCount ()const{return alloc_count;} ///<取得已分配的阵列大小(注：非字节数) const int64 GetAllocCount ()const{return alloc_count;} ///<取得已分配的阵列大小(注：非字节数)
const int GetBytes ()const{return count*sizeof(T);} ///<取得阵列已使用的字节数 const int64 GetBytes ()const{return count*sizeof(T);} ///<取得阵列已使用的字节数
const int GetAllocBytes ()const{return alloc_count*sizeof(T);} ///<取得阵列已分配空间字节数 const int64 GetAllocBytes ()const{return alloc_count*sizeof(T);} ///<取得阵列已分配空间字节数
const bool IsEmpty ()const{return(count==0);} ///<是否为空 const bool IsEmpty ()const{return(count==0);} ///<是否为空
@ -39,7 +39,7 @@ namespace hgl
/** /**
* 分配指定空间出来，供未来使用 * 分配指定空间出来，供未来使用
*/ */
bool Alloc(int size) bool Alloc(int64 size)
{ {
if(size<=alloc_count) if(size<=alloc_count)
return(true); return(true);
@ -59,7 +59,7 @@ namespace hgl
* @param size 阵列长度 * @param size 阵列长度
* @return 设置成功后的阵列长度 * @return 设置成功后的阵列长度
*/ */
int SetCount(int size) ///<设置阵列长度(注：非字节数) int64 SetCount(int64 size) ///<设置阵列长度(注：非字节数)
{ {
Alloc(size); Alloc(size);
@ -72,7 +72,7 @@ namespace hgl
* @param size 增加的长度 * @param size 增加的长度
* @return 增加后的阵列长度 * @return 增加后的阵列长度
*/ */
int AddCount(int size) int64 AddCount(int64 size)
{ {
return SetCount(count+size); return SetCount(count+size);
} }
@ -86,7 +86,7 @@ namespace hgl
alloc_count=0; alloc_count=0;
} }
DataArray(int size) DataArray(int64 size)
{ {
if(size<=0) if(size<=0)
items=nullptr; items=nullptr;
@ -149,22 +149,22 @@ namespace hgl
return items; return items;
} }
T &operator[](int n) T &operator[](int64 n)
{ {
return items[n]; return items[n];
} }
const T &operator[](int n)const const T &operator[](int64 n)const
{ {
return items[n]; return items[n];
} }
T *GetPointer(int n)const T *GetPointer(int64 n)const
{ {
return (n<0||n>=count)?nullptr:items+n; return (n<0||n>=count)?nullptr:items+n;
} }
const bool ReadAt(T &obj,int const index)const const bool ReadAt(T &obj,int64 const index)const
{ {
if(index<0||index>=count)return(false); if(index<0||index>=count)return(false);
@ -172,7 +172,7 @@ namespace hgl
return(true); return(true);
} }
const bool ReadAt(T *obj,int const start,const int num)const const bool ReadAt(T *obj,const int64 start,const int64 num)const
{ {
if(!obj||start<0||start+num>count)return(false); if(!obj||start<0||start+num>count)return(false);
@ -180,7 +180,7 @@ namespace hgl
return(true); return(true);
} }
const bool WriteAt(const T &obj,const int index) const bool WriteAt(const T &obj,const int64 index)
{ {
if(index<0||index>=count)return(false); if(index<0||index>=count)return(false);
@ -188,7 +188,7 @@ namespace hgl
return(true); return(true);
} }
const bool WriteAt(const T *obj,const int start,const int num) const bool WriteAt(const T *obj,const int64 start,const int64 num)
{ {
if(!obj||start<0||start+num>count)return(false); if(!obj||start<0||start+num>count)return(false);
@ -214,7 +214,7 @@ namespace hgl
void operator = (const std::initializer_list<T> &l) void operator = (const std::initializer_list<T> &l)
{ {
SetCount((int)l.size()); SetCount((int64)l.size());
hgl_cpy<T>(items,l.begin(),count); hgl_cpy<T>(items,l.begin(),count);
} }
@ -225,7 +225,7 @@ namespace hgl
* @param delete_count 要删除的数据项数量 * @param delete_count 要删除的数据项数量
* @return 是否成功 * @return 是否成功
*/ */
bool Delete(int start,int delete_count=1) bool Delete(int64 start,int64 delete_count=1)
{ {
if(!items)return(false); if(!items)return(false);
if(start>=count)return(false); if(start>=count)return(false);
@ -276,7 +276,7 @@ namespace hgl
* @param start 要删除的数据项的索引值 * @param start 要删除的数据项的索引值
* @return 是否成功 * @return 是否成功
*/ */
bool DeleteMove(int start,int delete_count=1) bool DeleteMove(int64 start,int64 delete_count=1)
{ {
if(!items)return(false); if(!items)return(false);
if(start>=count)return(false); if(start>=count)return(false);
@ -292,7 +292,7 @@ namespace hgl
if(delete_count<=0)return(false); if(delete_count<=0)return(false);
const int end_count=count-(start+delete_count); const int64 end_count=count-(start+delete_count);
if(end_count>0) if(end_count>0)
hgl_cpy<T>(items+start,items+start+delete_count,end_count); hgl_cpy<T>(items+start,items+start+delete_count,end_count);
@ -307,7 +307,7 @@ namespace hgl
* @param a 第一个数据的位置 * @param a 第一个数据的位置
* @param b 第二个数据的位置 * @param b 第二个数据的位置
*/ */
void Exchange(int a,int b) void Exchange(int64 a,int64 b)
{ {
hgl_swap(items[a],items[b]); hgl_swap(items[a],items[b]);
} }
@ -318,7 +318,7 @@ namespace hgl
* @param old_index 旧的位置 * @param old_index 旧的位置
* @param move_number 要移动的数据个数 * @param move_number 要移动的数据个数
*/ */
bool Move(int new_index,int old_index,int move_number=1) bool Move(int64 new_index,int64 old_index,int64 move_number=1)
{ {
if(!items)return(false); if(!items)return(false);
if(new_index==old_index)return(false); if(new_index==old_index)return(false);
@ -333,7 +333,7 @@ namespace hgl
if(move_number<=0)return(false); if(move_number<=0)return(false);
//直接创建新缓冲区复制过去，放弃旧缓冲区 //直接创建新缓冲区复制过去，放弃旧缓冲区
const int new_alloc_count=power_to_2(count); const int64 new_alloc_count=power_to_2(count);
T *new_items=hgl_align_malloc<T>(new_alloc_count); T *new_items=hgl_align_malloc<T>(new_alloc_count);
bool result; bool result;
@ -543,7 +543,7 @@ namespace hgl
* @param find_count 要查找的最大数量 * @param find_count 要查找的最大数量
* @return <0 未找到或其它错误 * @return <0 未找到或其它错误
*/ */
const int Find(const T &data,const int start=0,int find_count=-1)const const int64 Find(const T &data,const int64 start=0,int64 find_count=-1)const
{ {
if(!items||count<=0||start<0||start>=count)return(-1); if(!items||count<=0||start<0||start>=count)return(-1);
@ -556,7 +556,7 @@ namespace hgl
/** /**
* 在指定位置插入数据 * 在指定位置插入数据
*/ */
bool Insert(int pos,const T *data,const int data_number) bool Insert(int64 pos,const T *data,const int64 data_number)
{ {
if(!data||data_number<=0) if(!data||data_number<=0)
return(false); return(false);
@ -566,7 +566,7 @@ namespace hgl
if(count+data_number>alloc_count) if(count+data_number>alloc_count)
{ {
int new_alloc_count=power_to_2(alloc_count+data_number); int64 new_alloc_count=power_to_2(alloc_count+data_number);
T *new_items=hgl_align_malloc<T>(new_alloc_count); T *new_items=hgl_align_malloc<T>(new_alloc_count);
@ -591,7 +591,7 @@ namespace hgl
return(true); return(true);
} }
bool Insert(int pos,const T &data) bool Insert(int64 pos,const T &data)
{ {
return Insert(pos,&data,1); return Insert(pos,&data,1);
} }
@ -602,14 +602,14 @@ namespace hgl
void WithoutList(DataArray<T> &result_list,const DataArray<T> &without_list) void WithoutList(DataArray<T> &result_list,const DataArray<T> &without_list)
{ {
result_list.Clear(); result_list.Clear();
const int count=this->GetCount(); const int64 count=this->GetCount();
if(count<=0)return; if(count<=0)return;
result_list.Clear(); result_list.Clear();
result_list.PreAlloc(count); result_list.PreAlloc(count);
int result=0; int64 result=0;
T *p=result_list.items; T *p=result_list.items;
@ -626,8 +626,8 @@ namespace hgl
result_list.SetCount(result); result_list.SetCount(result);
} }
//int Intersection (SortedSets<T> &result,const SortedSets<T> &sets); ///<取得与指定合集的交集 //int64 Intersection (SortedSets<T> &result,const SortedSets<T> &sets); ///<取得与指定合集的交集
//int Intersection (const SortedSets<T> &set); ///<取得与指定合集的交集数量 //int64 Intersection (const SortedSets<T> &set); ///<取得与指定合集的交集数量
///** ///**
// * 取得与指定交集is的合集，但排斥cs合集中的数据 // * 取得与指定交集is的合集，但排斥cs合集中的数据
@ -636,9 +636,9 @@ namespace hgl
// * @param cs 求排斥的合集 // * @param cs 求排斥的合集
// * @return 结果数量 // * @return 结果数量
// */ // */
//int Intersection (SortedSets<T> &result,const SortedSets<T> &is,const SortedSets<T> &cs); //int64 Intersection (SortedSets<T> &result,const SortedSets<T> &is,const SortedSets<T> &cs);
//int Difference (const SortedSets<T> &is); ///<求差集数量 //int64 Difference (const SortedSets<T> &is); ///<求差集数量
///** ///**
// * 求当前合集与另一个数据集的交集 // * 求当前合集与另一个数据集的交集
@ -646,7 +646,7 @@ namespace hgl
// * @param list 要计算交集的数据集 // * @param list 要计算交集的数据集
// * @return 交集数量 // * @return 交集数量
// */ // */
//int Intersection(SortedSets<T> &result,const SortedSets<T> &list) //int64 Intersection(SortedSets<T> &result,const SortedSets<T> &list)
//{ //{
// if(data_list.GetCount()<=0) // if(data_list.GetCount()<=0)
// return(0); // return(0);
@ -663,7 +663,7 @@ namespace hgl
// return result.GetCount(); // return result.GetCount();
//} //}
//int Intersection(const SortedSets<T> &list) //int64 Intersection(const SortedSets<T> &list)
//{ //{
// if(data_list.GetCount()<=0) // if(data_list.GetCount()<=0)
// return(0); // return(0);
@ -671,10 +671,10 @@ namespace hgl
// if(list.GetCount()<=0) // if(list.GetCount()<=0)
// return(0); // return(0);
// int count=0; // int64 count=0;
// T *obj=data_list.GetData(); // T *obj=data_list.GetData();
// for(int i=0;i<data_list.GetCount();i++) // for(int64 i=0;i<data_list.GetCount();i++)
// { // {
// if(list.IsMember(*obj)) // if(list.IsMember(*obj))
// ++count; // ++count;
@ -685,7 +685,7 @@ namespace hgl
// return count; // return count;
//} //}
//int Intersection(SortedSets<T> &result,const SortedSets<T> &il,const SortedSets<T> &cl) //int64 Intersection(SortedSets<T> &result,const SortedSets<T> &il,const SortedSets<T> &cl)
//{ //{
// if(data_list.GetCount()<=0) // if(data_list.GetCount()<=0)
// return(0); // return(0);
@ -694,7 +694,7 @@ namespace hgl
// return(0); // return(0);
// T *obj=data_list.GetData(); // T *obj=data_list.GetData();
// for(int i=0;i<data_list.GetCount();i++) // for(int64 i=0;i<data_list.GetCount();i++)
// { // {
// if(il.IsMember(*obj)) // if(il.IsMember(*obj))
// if(!cl.IsMember(*obj)) // if(!cl.IsMember(*obj))
@ -705,7 +705,7 @@ namespace hgl
// return result.GetCount(); // return result.GetCount();
//} //}
//int Difference(const DataArray &is) //int64 Difference(const DataArray &is)
//{ //{
// if(data_list.GetCount()<=0) // if(data_list.GetCount()<=0)
// return(is.GetCount()); // return(is.GetCount());
@ -713,10 +713,10 @@ namespace hgl
// if(is.GetCount()<=0) // if(is.GetCount()<=0)
// return(data_list.GetCount()); // return(data_list.GetCount());
// int count=0; // int64 count=0;
// T *obj=data_list.GetData(); // T *obj=data_list.GetData();
// for(int i=0;i<data_list.GetCount();i++) // for(int64 i=0;i<data_list.GetCount();i++)
// { // {
// if(!is.IsMember(*obj)) // if(!is.IsMember(*obj))
// ++count; // ++count;
@ -727,6 +727,6 @@ namespace hgl
// return count; // return count;
//} //}
//int Clear (const SortedSets<T> &clear_sets); ///<清除指定合集中所有数据 //int64 Clear (const SortedSets<T> &clear_sets); ///<清除指定合集中所有数据
};//template<typename T> class DataArray };//template<typename T> class DataArray
}//namespace hgl }//namespace hgl

38
inc/hgl/type/SortedSets.h
View File

@ -14,15 +14,15 @@ namespace hgl
DataArray<T> data_list; DataArray<T> data_list;
bool FindPos(const T &flag,int &pos)const ///<查找数据如果插入后，会所在的位置，返回是否存在这个数据 bool FindPos(const T &flag,int64 &pos)const ///<查找数据如果插入后，会所在的位置，返回是否存在这个数据
{return FindInsertPositionInSortedArray(&pos,data_list,flag);} {return FindInsertPositionInSortedArray(&pos,data_list,flag);}
int FindPos(const T &flag)const{int pos;return FindPos(flag,pos)?pos:-1;} ///<查找数据如果插入后，会所在的位置 int64 FindPos(const T &flag)const{int64 pos;return FindPos(flag,pos)?pos:-1;} ///<查找数据如果插入后，会所在的位置
public: //属性 public: //属性
T * GetData ()const{return data_list.GetData();} ///<取得数据指针 T * GetData ()const{return data_list.GetData();} ///<取得数据指针
int GetCount ()const{return data_list.GetCount();} ///<取得数据总量 int64 GetCount ()const{return data_list.GetCount();} ///<取得数据总量
const bool IsEmpty ()const{return data_list.IsEmpty();} ///<确认列表是否为空 const bool IsEmpty ()const{return data_list.IsEmpty();} ///<确认列表是否为空
@ -40,15 +40,15 @@ namespace hgl
SortedSets()=default; SortedSets()=default;
virtual ~SortedSets()=default; virtual ~SortedSets()=default;
void SetCount (int count){data_list.SetCount(count);} ///<指定数据数量，一般用于批量加载前的处理 void SetCount (int64 count){data_list.SetCount(count);} ///<指定数据数量，一般用于批量加载前的处理
void PreAlloc (int count){data_list.Alloc(count);} ///<预分配指定数量的数据空间 void PreAlloc (int64 count){data_list.Alloc(count);} ///<预分配指定数量的数据空间
/** /**
* 查找数据是否存在 * 查找数据是否存在
* @param flag 数据 * @param flag 数据
* @return 数据所在索引，-1表示不存在 * @return 数据所在索引，-1表示不存在
*/ */
int Find (const T &flag)const int64 Find (const T &flag)const
{ {
return FindDataPositionInSortedArray(data_list,flag); return FindDataPositionInSortedArray(data_list,flag);
} }
@ -61,7 +61,7 @@ namespace hgl
* @return 插入的位置 * @return 插入的位置
* @reutrn -1 数据已存在，添加失败 * @reutrn -1 数据已存在，添加失败
*/ */
int Add (const T &data) int64 Add (const T &data)
{ {
if(data_list.GetCount()<=0) if(data_list.GetCount()<=0)
{ {
@ -73,7 +73,7 @@ namespace hgl
} }
else else
{ {
int pos; int64 pos;
if(FindPos(data,pos)) if(FindPos(data,pos))
return(-1); //数据已存在 return(-1); //数据已存在
@ -87,7 +87,7 @@ namespace hgl
/* /*
* 添加一批数据 * 添加一批数据
*/ */
int Add (T *dl,const int count) int64 Add (T *dl,const int64 count)
{ {
if(!dl||count<=0)return -1; if(!dl||count<=0)return -1;
@ -97,10 +97,10 @@ namespace hgl
data_list.Alloc(data_list.GetCount()+count); data_list.Alloc(data_list.GetCount()+count);
{ {
int pos; int64 pos;
int result=0; int64 result=0;
for(int i=0;i<count;i++) for(int64 i=0;i<count;i++)
{ {
if(FindPos(*dl,pos)) if(FindPos(*dl,pos))
break; break;
@ -115,11 +115,11 @@ namespace hgl
} }
} }
bool DeleteAt (const int pos){return data_list.DeleteMove(pos,1);} ///<删除一个数据,使用序号 bool DeleteAt (const int64 pos){return data_list.DeleteMove(pos,1);} ///<删除一个数据,使用序号
bool Delete (const T &data) ///<删除一个数据 bool Delete (const T &data) ///<删除一个数据
{ {
int pos=Find(data); int64 pos=Find(data);
if(pos==-1)return(false); if(pos==-1)return(false);
@ -132,12 +132,12 @@ namespace hgl
* @param count 数据个数 * @param count 数据个数
* @return 成功删除的数据个数 * @return 成功删除的数据个数
*/ */
int Delete(T *dp,const int count) int64 Delete(T *dp,const int64 count)
{ {
int total=0; int64 total=0;
int pos; int64 pos;
for(int i=0;i<count;i++) for(int64 i=0;i<count;i++)
{ {
pos=Find(*dp); pos=Find(*dp);
if(pos!=-1) if(pos!=-1)
@ -155,7 +155,7 @@ namespace hgl
void Free (){data_list.Free();} ///<清除数据，并释放内存 void Free (){data_list.Free();} ///<清除数据，并释放内存
void Clear (){data_list.Clear();} ///<清除数据，但不释放内存 void Clear (){data_list.Clear();} ///<清除数据，但不释放内存
bool Get (const int index,T &data) ///<根据序列号取得指定数据 bool Get (const int64 index,T &data) ///<根据序列号取得指定数据
{ {
if(index<0||index>=data_list.GetCount()) if(index<0||index>=data_list.GetCount())
return(false); return(false);