Teoria bàsica punters

/*--------------------------Operador New------------------------------*/

/* new : Reserva memòria al Heap (zona de memòria dinàmica).
 *       Podem "diferenciar" quatre tipus de new:
 *      1)  Per a una sola dada de tipus bàsic (char, int, bool...)
 *          new int; retorna un punter que el guardem a un int *p_int per exemple.
 *      2)  Per a una taula de tipus bàsics.
 *          new int[10]; retorna un punter a la primera casella de l'espai reservat.
 *      3)  Per a un struct. new structS;
 *      4)  Per a una classe. new ClassC;
 */
#include <iostream>
using namespace std;

struct Punt {
    int x, y;
};

class Cercle {
    double radi, centre_x, centre_y;
public:
    Cercle(double r, double x, double y)
    : radi(r), centre_x(x), centre_y(y) {}

    double con_radi() const { return radi; }
};

int main() {
    // (1)
    int *p_int = new int;
    *p_int = 1;
    cout << *p_int << endl;
    // (2)
    int *p_array = new int[10];
    *p_array = 1;
    *(p_array + 3) = 4;
    p_array[5] = 5;
    for (int i = 0; i < 10; ++i) cout << *(p_array + i) << " ";
    cout << endl;
    // (3)
    Punt *p_punt = new Punt;
    p_punt->x = 3;
    p_punt->y = 1;
    cout << p_punt->x << p_punt->y << endl;s
    // (4)
    Cercle *p_cercle = new Cercle(12.3, 5.1, 4.9);
    cout << p_cercle->con_radi() << endl;
    cout << (*p_cercle).con_radi() << endl;
}

/*--------------------------Operador Delete---------------------------*/

/* L'operador delete allibera (esborra) un espai de memòria reservat previament
 * amb un new, per a no provocar fugues de memòria. Podem distingir 2 versions:
 *      1) Alliberar objectes únics amb delete p;
 *      2) Alliberar taules amb delete[] p;
 */
#include <iostream>
using namespace std;

int main() {
    // (1)
    int *p = new int;
    *p = 5;
    cout << *p << endl;
    delete p;
    // (2)
    int *p2 = new int[1000];
    for (int i = 0; i < 1000; ++i) {
        p2[i] = i + 1;
    }
    delete[] p;
}


/*-------------------Memory leak (Fuga de memòria)--------------------*/

/* És dona una fuga de memòria quan reservem espai de memòria que no utilitzem o
 * que ja no necessitarem.
 * Per exemple, si reservem dos cops seguits un espai amb new a *p, p apuntarà
 * a l'espai creat més recent, i haurem perdut l'adreça de memòria del primer
 * espai que hem creat. S'ha d'intentar no reservar espais de memòria innecessaris.
 */

#include <iostream>
using namespace std;

int main() {
    int *p = new int;
    for (int i = 0; i < 100; ++i) p = new int;
    //En un principi
    //Però si seguim creant espais de memòria sense fer-los servir ni
    //guardant-ne la direcció, només tindrem un punter que apunta a *p,
    //havent malgastat 100 enters reservats.
}


/*-------------------Exemple: Seqüencia invertida---------------------*/

#include <iostream>
using namespace std;

struct Stair {
    int valor;
    Stair *anterior;
};

int main() {
    int n;
    cin >> n;
    Stair *node = new Stair;
    while (n != 0) {
        Stair *nodeaux = new Stair;
        nodeaux->valor = n;
        nodeaux->anterior = node;
        node = nodeaux;
        cin >> n;
    }
    while (node != 0) {
        cout << node->valor << ' ';
        node = node->anterior;
    }
}

//JosepRivaille