Foro de elhacker.net

Hola! creen que alguien que sepa mucho de pointers me podria decir que estoy hasiendo mal en esta funcion creo que esta cojiendo la memoria de donde no deviera espero alguien puda ayudarme solo voy a poner la function aqui si quieren el codigo completo dejenme saber

Hola no entiendo que quieres hacer, detalla mejor tu pregunta ya que tu codigo no es muy claro.

Si lo que quieres es invertir un arreglo de enteros una forma podria ser esta:

#include <iostream>
using namespace std;
 
void reverseArray(int *arreglo, int tamano){
    int *temp=new int[tamano];
    int pos=0;
 
    for(int i=0;i<tamano;i++) //Copiamos el arreglo
        temp[i]=arreglo[i];
 
    for(int j=tamano-1;j>=0;j--, pos++)  //Lo invertimos
        arreglo[pos]=temp[j];
 
    delete[] temp;  //Liberamos la memoria
}
 
void imprimirArreglo(int *arreglo,int tamano){
    for(int i=0;i<tamano;i++)
        cout<<arreglo[i]<<" ";
    cout<<endl;
}
 
 
int main()
{
    int arreglo[]={1,2,3,4,5,6,7,8,9,10,12,13};      //Definiamos el arreglo
    int tamano=sizeof(arreglo)/sizeof(int); //Tamano del arreglo
 
    imprimirArreglo(arreglo,tamano);
    reverseArray(arreglo,tamano);
    imprimirArreglo(arreglo,tamano);
 
    return 0;
}
 

Saludos...

Otra forma es intercambiar el ultimo por el primero, el 2 por el N-2,.... el i por el N-i hasta que se crucen los punteros.

Creo intentó hacer eso pero en tal caso es innecesario crear otro arreglo

La idea es buena, pero vamos a ver los fallos.
Creas un array dinámico para alojar la inversa del array que pasas y te mueves en él mediante aritmética de punteros, haciendo que el puntero mismo vaya variando. Cuándo lo quieres liberar con delete has perdido el puntero original que apunta al inicio de bloque con lo que fallas. La solución es crear un puntero permanente que guarde esa posición y usar otro para moverte por el array, tal que así:

arrayPtr2 = new int[size];
arrayPtr2pointer = arrayPtr2;

Ahora usas uno para moverte como te movías y el otro para liberar con delete.

Para llevar arrayPtr hasta el final hazlo con una simple operación, así quitas código y tiempo de proceso:
En vez de

if (i == 0)
    for (int j = 0; j < size; j++)
        arrayPtr++;

usa

arrayPtr += size-1;

La orden para eliminar un array es mediante

delete [] identificardor_de_array

y no con

delete identificador_de_array

Las órdenes para preparar el array arrayPtr y para realizar la copia del arrayPtr2 al arrayPtr sácalas del bucle de generación del arrayPtr2. Son trabajos diferentes.

La función debería quedarte algo como esto:

void reverse(int *arrayPtr, int size) {
    int *arrayPtr2pointer = new int[size];
    int *arrayPtr2 = arrayPtr2pointer;
 
    arrayPtr += size - 1;
    for (int i = 0; i < size; i++) {                
        *arrayPtr2 = *arrayPtr;
        arrayPtr--;
        arrayPtr2++;
    }
 
    arrayPtr++;  // Necesario porque en el último bucle se actualizan estos dos punteros
    arrayPtr2--;  // y sobrepasan los limites. Hay que regresarlos a su lugar.
 
    arrayPtr2 = arrayPtr2pointer;
    for (int i = 0; i < size; i++) {
        *arrayPtr = *arrayPtr2;
        arrayPtr++;
        arrayPtr2++;
    }
    delete [] arrayPtr2pointer;
}

Si la función no es para estudiar punteros, ni memoria dinámica y es solamente para invertir un array puedes dejar a un lado todo esto y usar código más normal.

Incluye en tu código lo siguiente:

#define SWAP(X,Y) { \
    (X) ^= (Y); \
    (Y) ^= (X); \
    (X) ^= (Y); \
}
 
#define ARRAY_LENGTH(X) sizeof(X)/sizeof(X[0])
 
void reverse(int array[], size_t size) {
    int i;
    for(i = 0; i < size / 2; ++i) {
        SWAP(array[i], array[size - i - 1]);
    }
}

En cuanto al tema de la funcion swap, se puede lograr lo mismo con sumas y restas.

muchas gracias a todos por ayudarme a resolver el problema