AlliedModders - Punteros en c++

Los punteros apuntan a una dirección de memoria. No es lo mismo que obtenga el valor a que obtenga la dirección de memoria del valor.

Puedes usar dos operadores básicos dentro de los punteros. &(Direccionamiento) y *(Indireccionamiento)

Sintaxis:

int *ptrA, A;
A = 5;
ptrA = &A; // puntero a la variable A

ptrA es un puntero a int, mientras que la variable A es solo una variable del tipo int.
Todo puntero debe ser precedido por un asterisco (*).
Un puntero si es constante NO PUEDE ser modificado. int *const ptrA = 5; Puede alterarse solo si apunta a una variable y esta se modifica.

Si tengo un puntero A que apunta a la posición X y tengo otro puntero B que apunta a X, si yo modifico el puntero A, el puntero B se va a modificar también. Si yo modifico la variable X, ambos punteros se van a modificar.

Te dejo unos ejemplos hechos por mi, ojalá los entiendas y conozcas alguno de sus usos. (Están hechos en un compilador no muy bueno Dev c++)

Code:

// Operadores Simples



#include <iostream>

using namespace std;



main()

{

      int a = 3, *b = &a;

      

      cout << "a: " << a << endl << "b: " << b << " ( " << *b << " )" << endl;

      

      system("pause");

}

Code:

// Operadores Simples con puntero constante



#include <iostream>

using namespace std;



main()

{

      int a = 3;

      const int * const b = &a;

      

      cout << "a: " << a << " - b: " << *b << endl;

      a = 5;

      cout << "a: " << a << " - b: " << *b << endl;      

      

      system("pause");

}

Code:

// Función valor por referencia.



#include <iostream>

using namespace std;



// Esta Función permite que la variable b

void Funcion(int *a)

{

       *a+= (*a * 2);  

}



main()

{

      int b = 5;

      

      cout << "valor: " << b << endl;

      Funcion(&b); // La variable b obtiene su nuevo valor, sin necesidad de hacer que la variable retorne el resultado de la función

      cout << "valor: " << b << endl;

      

      system("pause");

}

Code:

// Retornar un arreglo de Enteros



#include <iostream>

using namespace std;



int *Arreglo(int a)

{

       int i, Arr[10];

       

       for(i = 0; i < 10; i++)

       {

              Arr[i] = a + (i * 2);

       }

       

       return Arr;

}



main()

{      

      int a, *b;

      

      b = Arreglo(5); 

      a = *(b + 2); // b sería el primer elemento del arreglo, entonces b + 2 es el 3er elemento. SE DEBE RESPETAR EL PARENTESIS.

      

      cout << "valor: " << a << endl;

      

      system("pause");

}

Code:

// Recorrer un Arreglo de Enteros



#include <iostream>

using namespace std;

 

main()

{

    int arr[6] = { 1, 3, 5, 7, 9, 20 };

    int *a;

 

    a = arr; // Puntero toma valor del arreglo int

 

    // La x es el valor que se va a mostrar

    cout << *a << endl; //[x][3][5][7][9][20]

    a+= 2;

    cout << *a << endl; //[1][3][x][7][9][20]

    a-= 1;

    cout << *a << endl; //[1][x][5][7][9][20]

    a+= 4;

    cout << *a << endl; //[1][3][5][7][9][x]

    a-= 2;

    cout << *a << endl; //[1][3][5][x][9][20]

    

    system("pause");

}

Code:

// Punteros entre funciones



#include <iostream>

using namespace std;



//Una función es la dirección de memoria de donde comienza el código. Por ende se puede retornar entre funciones.

bool functionA(int param1, bool (*verificar)(int))

{

        if(((*verificar)(param1)))

        {

                return true;

        }

        return false;

}

 

bool functionB(int param)

{

        if(param & 1) // Es una forma de obtener los números impares mediante el uso de operadores Binarios

        {

                return false;

        }

        else

        {

                return true;

        }

}

 

main()

{

    int x = 110;

    bool a = functionA(x, functionB); // El segundo parametro es un puntero a la función B

    

    if(a)

    {

          cout << "Es Par" << endl;

    }

    else

    {

          cout << "Es Impar" << endl;

    }

                

    system("pause");

}

También te voy a agregar uno de una lista enlazada, no es complicado de entender.

Code:

#include <iostream>

using namespace std;



class Nodo {

        private:

                int value;                  

        

        public:

                Nodo *next;

                Nodo(int value) // Constructor

            {

                         this->value = value;

                         next = NULL;

                }

                int GetValue() 

            {

                        return value;

                }

};



main()

{

      int val, i;

      Nodo *head = NULL, *aux2;   

      

      for(i = 0; i < 4; i++)

      {       

              cout << "Ingresa Un valor: ";

              cin >> val;   

              

              if(head == NULL)

                  {

                                         head = new Nodo(val);     

                     aux2 = head;                           

                          }

                                

                          else

                          {

                                         Nodo *body = head;

                                        

                                         while(body->next != NULL)

                                         {

                                                  body = body->next;

                                     }

                                        

                                         body->next = new Nodo(val);         

                          }

      }

     

      cout << endl << "Listando..." << endl;        

                        

          Nodo *aux = aux2;                

      while(aux != NULL)

      {

                         cout << aux->GetValue() << endl;             

                         aux = aux->next;

      } 

      system("pause");

}

Disculpa pero no sé como redactarlo de una mejor forma más teórica.

Quiero agregar por último que cuando veas Nodos, Lista enlazada, Stacks, Queue, Arbol binario y otros métodos avanzados, vas a utilizar MUCHO los punteros.