mirror of
https://github.com/1dot13/source.git
synced 2026-07-29 13:52:17 +02:00
897d3737c4
AutoCArray takes its allocator and deallocator as template parameters:
template<typename T, typename void*(*Alloc)(size_t) = malloc,
typename void(*Dealloc)(void*) = free>
Alloc and Dealloc are function pointers, so they are values, not types, and
typename has no business in front of them. MSVC ignores the keyword there;
clang stops at it and cannot parse the parameter list, which fails every
translation unit that reaches this header.
Removing the two stray keywords leaves the parameters exactly as they were
meant to be read, with the same defaults of malloc and free. Nothing in the
tree instantiates AutoCArray, so nothing depends on the spelling either way.
Verification:
grep -rn 'AutoCArray' --include=*.cpp --include=*.h . # only this header
ninja -C build parse # sgp_auto_memory.h clean
ninja -C build -k 0 # Release, four applications, green
ninja -C build-debug -k 0 # Debug, four applications, green
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
112 lines
1.7 KiB
C++
112 lines
1.7 KiB
C++
#ifndef _SGP_AUTO_MEMORY_H_
|
|
#define _SGP_AUTO_MEMORY_H_
|
|
|
|
namespace sgp
|
|
{
|
|
/************************************************************/
|
|
|
|
template<typename T>
|
|
class TAutoArray
|
|
{
|
|
public:
|
|
T& operator[](size_t index)
|
|
{
|
|
return _array[index];
|
|
}
|
|
|
|
T* operator()()
|
|
{
|
|
return _array;
|
|
}
|
|
T* operator->()
|
|
{
|
|
return _array;
|
|
}
|
|
T& operator*()
|
|
{
|
|
return *_array;
|
|
}
|
|
bool operator!()
|
|
{
|
|
// NULL == _array
|
|
return !_array;
|
|
}
|
|
|
|
T* release()
|
|
{
|
|
T* tmp = _array;
|
|
_array = NULL;
|
|
return tmp;
|
|
}
|
|
protected:
|
|
T* _array;
|
|
};
|
|
|
|
/************************************************************/
|
|
|
|
template<typename T>
|
|
class AutoArray : public TAutoArray<T>
|
|
{
|
|
public:
|
|
AutoArray(size_t size)
|
|
{
|
|
_array = new T[size];
|
|
}
|
|
~AutoArray()
|
|
{
|
|
if(_array)
|
|
{
|
|
delete[] _array;
|
|
}
|
|
}
|
|
};
|
|
|
|
/************************************************************/
|
|
|
|
template<typename T, void*(*Alloc)(size_t) = malloc, void(*Dealloc)(void*) = free>
|
|
class AutoCArray : public TAutoArray<T>
|
|
{
|
|
public:
|
|
AutoCArray(size_t size = 1, size_t sizeof_elem=1)
|
|
{
|
|
_array = (T*)Alloc( size * sizeof_elem );
|
|
}
|
|
~AutoCArray()
|
|
{
|
|
if(_array)
|
|
{
|
|
Dealloc(_array);
|
|
}
|
|
}
|
|
};
|
|
|
|
/************************************************************/
|
|
|
|
} // namespace sgp
|
|
|
|
|
|
#include "MemMan.h"
|
|
|
|
namespace sgp
|
|
{
|
|
template<typename T>
|
|
class AutoMMArray : public sgp::TAutoArray<T>
|
|
{
|
|
public:
|
|
AutoMMArray(size_t size, size_t sizeof_elem=1)
|
|
{
|
|
_array = (T*)MemAlloc( size * sizeof_elem );
|
|
}
|
|
~AutoMMArray()
|
|
{
|
|
if(_array)
|
|
{
|
|
MemFree(_array);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
#endif // _SGP_AUTO_MEMORY_H_
|