¿Como ves mejor tu código?

Así:

void** RedimPreserve( void** __pp_vector , size_t _szt_now, size_t _szt_new )
{
    void            **__pp_back     = __pp_vector;
    void            **__new_ptr     = NULL;
 
    if (_szt_now==_szt_new )
        return __pp_vector;
 
    if ( _szt_new>0 ) {
        __new_ptr       = new void*[_szt_new];
        if ( _szt_now>0 && __new_ptr!=NULL && __pp_back!=NULL  )
            if ( _szt_now>_szt_new )
                memcpy          ( __new_ptr , __pp_back , _szt_new*sizeof(void*) );
            else
                memcpy          ( __new_ptr , __pp_back , _szt_now*sizeof(void*) );
    } else
        __new_ptr       = NULL;
 
    if ( __pp_back!=NULL )
        delete[]        __pp_back;
 
    return __new_ptr;
}
 

O de esta manera:

void ** RedimPreserve(void ** buff, size_t currentSize, size_t newSize)
{
    void ** currentBuff = buff;
    void ** temp = NULL;
 
	if (currentSize == newSize)
		return buff;
 
	if (newSize > 0)
	{
		temp = new void*[newSize];
		if (currentSize > 0 && temp != NULL && currentBuff != NULL)
			if (currentSize > newSize)
				memcpy(temp, currentBuff, newSize * sizeof(void*));
			else
				memcpy(temp, currentBuff, currentSize * sizeof(void*));
	}
	else
		temp = NULL;
 
	if (buff != NULL)
		delete[] buff;
 
return temp;
}
 

Programar es un arte, y para un programador es un deber escribir buen código y que sea legible por otros.

Saludos.

No me gusta declarar variables sin tener prefijos que NO me indiquen que tipo de variables son... es decir me guio en la nomeclatura hungara que de hecho estan hay por algo, es decir, mantenimiento de codigo a corto, media y largo plazo.

Digamoslo de esta manera:

Tienes 40 declaraciones de variables en un proceso X y varias lineas en tu proceso, si les pongo solo nombres sin que digan mucho ( tipo y/o clase ), y se lo doy a otro programador, este ultimo para que modificara solo 3 lineas, el pobre tendria que irse hasta donde estan declaradas las varibales para saber de que tipo son, y tambien para saber si se estan tratando variables tipo <Puntero>, <Puntero a Puntero> o en un caso mas raro saber si son <Punteros a Punteros a Puntero>, seria algo muy tedioso esto la vdd.

temp, Current, etc y si se desea hacer un cast entre tipos distintos, pues tendria el programador que estar transladandose a zonas que no tendria que transladarse a cada instante.

__pp_ <.. Puntero a puntero algunos solo hacen un    pNombreVariable...  yo le pongo los "_" solo para separar esta nomeclatura ( aun que estoy pensando solo realizar esto para los punteros de cualquier tipo... )

_tipo_nombre     otros ->  tipoNombre     ( Como dije estoy pensando en quitar los _ y dejarselo solo a los punteros... )

un ejemplo de lo que digo:

 
    if (_szt_now==_szt_new )
        return __pp_vector;
 
    if ( _szt_new>0 ) {
        __new_ptr       = new void*[_szt_new];
        if ( _szt_now>0 && __new_ptr!=NULL && __pp_back!=NULL  )
            if ( _szt_now>_szt_new )
                memcpy          ( __new_ptr , __pp_back , _szt_new*sizeof(void*) );
            else
                memcpy          ( __new_ptr , __pp_back , _szt_now*sizeof(void*) );
    } else
        __new_ptr       = NULL;
 
    if ( __pp_back!=NULL )
        delete[]        __pp_back;
 
    return __new_ptr;
 
 

y tu codigo:

 
	if (currentSize == newSize)  
		return buff;
 
	if (newSize > 0)
	{
		temp = new void*[newSize];
		if (currentSize > 0 && temp != NULL && currentBuff != NULL)
			if (currentSize > newSize)
				memcpy(temp, currentBuff, newSize * sizeof(void*));
			else
				memcpy(temp, currentBuff, currentSize * sizeof(void*));
	}
	else
		temp = NULL;
 
	if (buff != NULL)
		delete[] buff;
 
return temp;
 
 

Ahora dime de que tipo son cada variable... solo lo sabrias si analizas el codigo pero eso conlleva tiempo... en mi caso si sabes que significan cada prefijo sabes que tipo son sin mayor problema.

otro ejemplo seria detectar errores entre comparaciones de Enteros con signo y enteros sin signo y asi detectar con tan solo ver las variables donde radica el error.

Ej:

 
//Suponiendo que las variables estan perdidas en alguna parte del codigo... pero las variables tienen prefijos...
dwVar  = -1;   // _dw_Var <--- yo lo haria asi pero creo que si quitare los "_"...
//Tendriamos que verificar que dwvar no sea menor a 0 ya que udwvar no acepta numeros negativos... aun que tiene sus equivalencias.
udwvar = dwvar;  //  Se tendria que hacer un casting...   ( -1 == -2147483648 )
 
 

si no tuviera prefijos...

 
//Suponiendo que las variables estan perdidas en alguna parte del codigo... pero las variables tienen prefijos...
// De que tipo es?... vamos a tener que buscar las desgraciadas variables... y esperemos que esten en donde se deberian declarar, si no tendremos que buscar en todo el codigo ¬¬".
Numero1  = -1;
Numero2 = Numero1; //<--- Si aqui genera un error, y no sabemos porque, seguro haremos un casting... pero las variables pueden albergar la misma cantidad? es decir pesa lo mismo en memoria? o tenemos que cambiar el tipo de la variable para que soporte Numero2 a Numero1 y no se puedan bits/bytes(segun sea el caso)?.
 
 

Los codigo de los sitemas Operativos y/o programas variados tienen nomeclaturas similares y no manejan en muchos casos el tipo de declaraciones que aqui Todos han mencionado (Con excepciones claro). seguramente cada empresa de software maneja y/o define una nomeclatura "X" aun que otras pueden usar la nomeclatura recomendada y que mas se usa.

Como has dicho Programar es un arte y debe ser de facil interpretacion sea cual sea el caso...

Nota: A mi nomeclatura solo le he agregado "_" para separar nombre de tipos, y no morir en el intento, aun que no es la misma nomeclatura que se usa en las estructuras y demas debido a los "_" se comprende.

Dulces Lunas!¡.

Si bueno los _ como ya dije los usare para punteros de esa manera no los mesclare con el prefijo que designa al tipo, esto si no lo cmabiare, lo de las tabulaciones loq ue yaho yo es tener una linea imaginaria que me permita ordenar las asignaciones y no me genere personalmente peresa visual.

 
asdasd = asd;
asds=asd;
asdsadasdsad=sd
asdsd=sad;
asds=a;
d=s;
 
 

lo que hago es ordenarlo de esta manera

 
asdasd          = asd;
asds            = asd;
asdsadasdsad    = sd
asdsd           = sad;
asds            = a;
d               = s;
 
 

lo hago solo por la peresa viisual que me genera al ver tanto codigo juntado, lo del memcpy fue un error... ya que lo en C lo hago de esta manera.

 
memcpy(
       __new_ptr , 
       __pp_back , 
       _szt_now*sizeof(void*)
       );
 
 

Pero como estoy haciendo pruebas y aun no comento nada lo dejo lineal para saber donde le faltan comentarios ( Muy breves pero explicitos ).

P.D.: Al final deje esta funcion de largo y use realloc() y malloc() para esto, dejando a new y delete para las clases.

Dulces Lunas!¡.

pero siguiendo tu lógica de programación el siguiente código:

void** RedimPreserve( void** __pp_vector , size_t _szt_now, size_t _szt_new )
{
    void            **__pp_back     = __pp_vector;
    void            **__new_ptr     = NULL;
 
    if (_szt_now==_szt_new )
        return __pp_vector;
 
    if ( _szt_new>0 ) {
        __new_ptr       = new void*[_szt_new];
        if ( _szt_now>0 && __new_ptr!=NULL && __pp_back!=NULL  )
            memcpy          ( __new_ptr , __pp_back , _szt_now*sizeof(void*) );
    } else
        __new_ptr       = NULL;
 
    if ( __pp_back!=NULL )
        delete[]        __pp_back;
 
    return __new_ptr;
}

es más entendible de la forma: (size_t == unsigned integer)

void** RedimPreserve( void** __vVector , size_t uNow, size_t uNew ){
    void            **__vBack     = __vVector;
    void            **__vNewPtr     = NULL;
 
    if (uNow==uNew )
        return __vVector;
 
    if ( uNew>0 ) {
        __vNewPtr       = new void*[uNew];
        if ( uNow>0 && __vNewPtr!=NULL && __vBack!=NULL  )
            memcpy          ( __vNewPtr , __vBack , uNow*sizeof(void*) );
    } else
        __vNewPtr       = NULL;
 
    if ( __vBack!=NULL )
        delete[]        __vBack;
 
    return __vNewPtr;
}

aunque preferiría el modo:

void** RedimPreserve( void** ppvVector , size_t uNow, size_t uNew ){
    void            **ppvBack     =ppvVector;
    void            **ppvNewPtr     = NULL;
 
    if (uNow==uNew )
        return ppvVector;
 
    if ( uNew>0 ) {
        ppvNewPtr       = new void*[uNew];
        if ( uNow>0 && ppvNewPtr!=NULL && ppvBack!=NULL  )
            memcpy          ( ppvNewPtr , ppvBack , uNow*sizeof(void*) );
    } else
        ppvNewPtr       = NULL;
 
    if ( ppvBack!=NULL )
        delete[]        ppvBack;
 
    return ppvNewPtr;
}

S2

PD: Ni vi el código... solo la nomenclatura, de todas formas el código de rir3760 parece estar bien (y suele estarlo dado que le gustan este tipo de algoritmos )