Foro de elhacker.net

.
mi problema es que en TEORIA mi funcion setnewptr deberia de asignar y/o devolver en el parametro old el puntero a New, pero solo lo afecta dentro de la funcion mas cuando termina no me afecta a c_pstr... ¿Como puedo solucionar esto?...

Aquí lo que digo...

 
#include<iostream>
#include<cstdlib>
#include<cstring>
 
using namespace std;
 
void* setnewptr( void *old , void *New);
 
int main() {
    char *c_pstr = NULL;
    char *c_str = (char*)malloc(sizeof(char)*10);
    strcpy(c_str , (const char*)"Hola");
    cout << (char*)setnewptr( c_pstr , c_str );
    cout << c_pstr << endl;
    return 0;
}
 
void* setnewptr( void *old , void *New)
/**
    Libera a [*old] si apunta a algo y le establece [*New];
    By BlackZeroX ( http://Infrangelux.sytes.net/ )
**/
{
    if ( old != NULL )
        free (old);
    return old=New;
}
 
 

Buenas,

para reservar y liberar memoria en c++ tienes new y delete.

No se modifica fuera de la función porque new y old son copias, lo que estas pasando por referencia son las direcciones a la memoria reservada para la cadena, no a los punteros que es lo que tu intentas modificar en la función, como puedes comprobar si modificas así el programa:

 

#include<iostream>
#include<cstdlib>
#include<cstring>
 
using namespace std;
 
void* setnewptr( void *old , void *New);
 
int main() {
    char *c_pstr = NULL;
    char *c_str = (char*)malloc(sizeof(char)*10);
    strcpy(c_str , (const char*)"Hola");
    cout << (char*)setnewptr( c_pstr , c_str );
    c_pstr=(char *)setnewptr(c_pstr,c_str); 
    cout << c_pstr << endl;
    return 0;
}
 
void* setnewptr( void *old , void *New)
/**
    Libera a [*old] si apunta a algo y le establece [*New];
    By BlackZeroX ( http://Infrangelux.sytes.net/ )
**/
{
    if ( old != NULL )
        free (old);
    return old=New;
}

Lo que en realidad queres pasarle a la funcion son punteros a punteros o referencias a punteros (en caso de ser C++)...

lo se.

 
c_pstr=(char *)setnewptr(c_pstr,c_str); 
 
 

Es lo que quiero evitar, ya que actualmente asi es como lo estoy haciendo.

Lo que quiero evitar es hacer una igualdad  asi a=b.

Dulces Lunas!¡.

Vos no queres algo asi?

 
void setnewptr( void* &old , void* &New){ //tomo referencias a puntero
    if ( old != NULL )
        free (old);
    old=New;
}
 
//y se usa:...
void* p_viejo = ... ;
void* p_nuevo = ... ;
 
setnewptr(p_viejo,p_nuevo);
 

Otra forma es:

 
void setnewptr( void** old , void** New){//tomo puntero a puntero
    if ( *old != NULL )
        free (*old);
    *old=*New;
}
 
//y se usa:...
void* p_viejo = ... ;
void* p_nuevo = ... ;
 
setnewptr(&p_viejo,&p_nuevo); //notece q lo que paso por parametro es un puntero a puntero
 

Y la q mas me gusta:

 
template<class T> 
void setnewptr( T* &old , T* &New){ //tomo referencias a puntero, pero ahora no hacen falta casteos a void*...
    if ( old != NULL )
        free (old);
    old=New;
}
 
//y se usa:...
Tipo1* p_viejo = ... ;
Tipo1* p_nuevo = ... ;
 
setnewptr(p_viejo,p_nuevo); //no me fije si compila, pero debe compilar, el compilador solo puede inferir el tipo...
 

.
@puchero

gracias no sabia eso de la referencia al puntero con el signo &.

Me quedare con esta.

 
template<class T>
T* setnewptr( T *&old , T *New)
{
    if ( old != NULL )
        delete (old); // free (old);
    return old=New;
}
 
 

Temibles Lunas!¡.