Re: My Hand-Rolled Dynamic Arrays.
Jeff,
The source code is NOT written for computers. Source code IS written for
people to read. For those poor code maintainers and your teammates (which
I'm afraid you don't have). It should be as much plain and boring as
possible. Yes, it's possible to write highly efficient and optimal code
which at the same time looks plain and boring. The code, by means of C
langusg, and sometimes by means of human language, should say exactly what
you mean, to those poor readers of your code. If you think you save 5
minutes writing the code, by using those macros, you will waste hours of
people trying to maintain such kind of code. Any bug in the code becomes
very hard to find. This is what "Writing Solid Code" is all about. If _I_
had to fix your code, I would just throw it into a bit bucket and rewrote
from scratch. This would simply save time. Then all the glory you think you
had with it is lost forever. I won't even try to review it for correctness.
If I was working at the codebase and saw it, I would immediately know which
code is wrong.
"Jeff?Relf" <Jeff_Relf@Yahoo.COM> wrote in message
news:Jeff_Relf_2007_Nov_3__8_32_Pq@Cotse.NET...
The code below shows how I increment a dynamic array of pointers.
I use overloading and a template but not member functions.
#define CRLF ( Ch == 10 || Ch == 13 )
#define While( Should_Loop ) Ch = 1 , P -- ; \
while ( Ch \\
&& ( Ch = * ++ P , Ch2 = ! Ch ? 0 : P [ 1 ] , Should_Loop ) )
#define Zero( X ) memset( & X, 0, sizeof X )
#define LoopXx( Tt, _Xx ) \
Tt##T & Xx = _Xx ; Tt##P P = 0, B ; int J = -1 ; \
Tt##A BB = Xx.BB, EE = Xx.PP + 1 , PP = BB - 1 ; \
if ( BB ) while ( ++ J , B = P = * ++ PP , PP < EE )
#define ReBuff( N ) ( \
B_Cache = MallocTmp( Max_Buff = ER ( N, Max_Header ) ) \
, B_Sh = MallocTmp( Max_Sh = Max_Buff ) )
#define NewHeap ( Heap = HeapCreate( HEAP_NO_SERIALIZE, 0, 0 ) \
, ReBuff( 0 ), Ptrs = ( LnA ) MallocTmp( SzPtrs = 10000 * SzPtr ) )
#define MallocTmp( Sz ) ( LnP ) HeapAlloc( Heap, 0, Sz )
#define ReAlloc_Tmp( P, Sz ) _HeapReAlloc( Heap, 0, P, Sz )
#define ReAlloc( P, Sz ) ( LnP ) realloc( P, Sz )
typedef uchar * _LnP ; typedef char * __LnP ;
typedef wchar_t * LnP ; typedef LnP * LnA ;
// This holds the dyanmic array
struct LnT { LnA BB, PP, EE ; };
inline LnP _HeapReAlloc( HANDLE H, uint F, void * P, int Sz ) {
return LnP(
P ? HeapReAlloc( H, F, P, Sz ) : HeapAlloc( H, F, Sz ) ); }
// Code is from X.CPP in " www.Cotse.NET/users/jeffrelf/Games.ZIP ".
template < typename TyT, typename TyA, typename TyP >
TyP & Inc( TyT & Xx, int N ) { int Temp_Heap = N >= 0 ;
if ( ! Temp_Heap ) N = 1 ;
int I_PP = ! Xx.PP ? -1 : Xx.PP - Xx.BB, I_EE = Xx.EE - Xx.BB
, New_I_PP = I_PP + N, New_I_EE = New_I_PP + 1024 ;
if ( New_I_PP >= I_EE ) { int Sz = New_I_EE * SzPtr ;
if ( Temp_Heap )
Xx.BB = ( TyA ) _HeapReAlloc( Heap, HEAP_ZERO_MEMORY, Xx.BB, Sz );
else { int Sz_Dif = Sz - I_EE * SzPtr ;
if ( Sz_Dif > 0 ) {
Xx.BB = ( TyA ) ReAlloc( Xx.BB, Sz );
memset( Xx.BB + I_EE, 0, Sz_Dif ); } }
Xx.EE = Xx.BB + New_I_EE ; }
return * ( Xx.PP = Xx.BB + New_I_PP ); }
// The 1 indicated that a temporary heap should be used.
AgP & Inc ( AgT & Ag ) { return Inc< AgT, AgA, AgP> ( Ag, 1 ) ; }
UsP & Inc ( UsT & Us ) { return Inc< UsT, UsA, UsP> ( Us, 1 ) ; }
LsP & Inc ( LsT & Ls ) { return Inc< LsT, LsA, LsP> ( Ls, 1 ) ; }
LnP & Inc ( LnT & Ln ) { return Inc< LnT, LnA, LnP> ( Ln, 1 ) ; }
// The N indicates how many pointers are to be added to the dynamic
array.
LnP & Inc ( LnT & Ln, int N ) {
return Inc< LnT, LnA, LnP> ( Ln, N ) ; }
// The -1 indicates that the bog-standard ** heap should be used.
// ** http://WikiPedia.ORG/wiki/Bog_standard
TbP & Inc ( TbT & Tb ) { return Inc< TbT, TbA, TbP> ( Tb, -1 ) ; }
SrP & Inc ( SrT & Sr ) { return Inc< SrT, SrA, SrP> ( Sr, -1 ) ; }
GyP & Inc ( GyT & Gy ) { return Inc< GyT, GyA, GyP> ( Gy, -1 ) ; }
// ShBot() ensures that the last printed line is visible.
ShBot() {
VisLn = ER ( 0, Ln.PP - Ln.BB - ScrRows + 2 ), PaintReq = 1 ; }
int _Sh ( LnP B ) { LnP P = B, E ; int Ch, Ch2, Two = -1, Len ;
While ( ! CRLF ); E = P ; While ( CRLF ) if ( Ch == 10 ) Two ++ ;
* E = 0, Len = 1 + E - B ;
wmemmove ( Inc ( Ln ) = MallocTmp ( Len * SzChar ), B, Len );
ShBot();
if ( Two > 0 ) P -- ; return ! * P ? -- Len : _Sh ( P ); }
// Sh() prints a line to a Maximized_Window/Primary_Surface.
#define Printed ( \
Sz_Sh = Str_Stk ( B_Sh, Max_Sh - 3, S, ( __LnP ) & S + SzPtr ) )
#define Sh_Silent \
while ( Printed < 0 ) B_Sh = MallocTmp( Max_Sh *= 2 );
int Max_Sh, Sz_Sh ; LnP B_Sh ;
int Sh ( LnP S, ... ) { Sh_Silent return _Sh( B_Sh ); }
SwitchHeap() { Zero( Ls ), Zero( Ag ), Zero( Path ), Zero( Us );
LnT _Ln = Ln ; Zero( Ln ); HANDLE H = Heap ; NewHeap;
LoopXx ( Ln, _Ln ) if ( P ) Sh( L"%s", P );
VisLn = 0 ; HeapDestroy( H ); }