La gestió de memòria és un aspecte crucial en la programació de jocs, especialment quan es treballa amb un motor tan potent com Unreal Engine. En aquest mòdul, aprendrem com gestionar la memòria de manera eficient per assegurar que els nostres jocs funcionin de manera fluida i sense problemes.

Conceptes Clau

  1. Memòria Dinàmica vs. Memòria Estàtica:

    • Memòria Estàtica: Assignada en temps de compilació i alliberada automàticament quan el programa finalitza.
    • Memòria Dinàmica: Assignada en temps d'execució i necessita ser alliberada manualment per evitar fuites de memòria.
  2. Punter i Referències:

    • Punter: Una variable que emmagatzema l'adreça de memòria d'una altra variable.
    • Referència: Un àlies per a una variable existent, que no pot ser nul·la.
  3. Gestió Automàtica de Memòria:

    • Garbage Collection: Unreal Engine utilitza un sistema de recollida d'escombraries per gestionar la memòria automàticament en alguns casos, especialment amb Blueprints.

Exemples Pràctics

Exemple 1: Assignació i Alliberament de Memòria Dinàmica en C++

#include <iostream>

void assignarMemoria() {
    // Assignació de memòria dinàmica per a un enter
    int* ptr = new int;
    *ptr = 10;

    std::cout << "Valor assignat: " << *ptr << std::endl;

    // Alliberament de memòria
    delete ptr;
}

int main() {
    assignarMemoria();
    return 0;
}

Explicació:

  • new int assigna memòria dinàmica per a un enter.
  • delete ptr allibera la memòria assignada per evitar fuites de memòria.

Exemple 2: Ús de Smart Pointers

Unreal Engine recomana l'ús de smart pointers per gestionar la memòria de manera més segura i eficient.

#include <memory>
#include <iostream>

void usarSmartPointer() {
    // Creació d'un smart pointer
    std::unique_ptr<int> ptr = std::make_unique<int>(20);

    std::cout << "Valor assignat: " << *ptr << std::endl;
}

int main() {
    usarSmartPointer();
    return 0;
}

Explicació:

  • std::unique_ptr és un tipus de smart pointer que gestiona la memòria automàticament.
  • std::make_unique<int>(20) assigna memòria i inicialitza el valor a 20.

Exercicis Pràctics

Exercici 1: Assignació Dinàmica de Memòria per a un Array

Objectiu: Crear un array dinàmicament i alliberar la memòria després d'usar-lo.

#include <iostream>

void assignarArray() {
    // Assignació de memòria per a un array de 5 enters
    int* array = new int[5];

    // Assignació de valors
    for (int i = 0; i < 5; ++i) {
        array[i] = i * 2;
    }

    // Impressió de valors
    for (int i = 0; i < 5; ++i) {
        std::cout << "Valor a l'índex " << i << ": " << array[i] << std::endl;
    }

    // Alliberament de memòria
    delete[] array;
}

int main() {
    assignarArray();
    return 0;
}

Solució

#include <iostream>

void assignarArray() {
    int* array = new int[5];

    for (int i = 0; i < 5; ++i) {
        array[i] = i * 2;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << "Valor a l'índex " << i << ": " << array[i] << std::endl;
    }

    delete[] array;
}

int main() {
    assignarArray();
    return 0;
}

Errors Comuns i Consells

  1. Fuites de Memòria:

    • No oblidis alliberar la memòria assignada dinàmicament amb delete o delete[].
    • Utilitza smart pointers per evitar fuites de memòria automàticament.
  2. Accés a Memòria No Vàlida:

    • Assegura't que els punters no apunten a memòria alliberada.
    • Inicialitza els punters a nullptr després d'alliberar la memòria.

Resum

En aquesta secció, hem après els conceptes bàsics de la gestió de memòria en C++ i com aplicar-los en el context d'Unreal Engine. Hem vist exemples pràctics d'assignació i alliberament de memòria, així com l'ús de smart pointers per gestionar la memòria de manera més segura. També hem practicat amb exercicis per reforçar aquests conceptes. En el proper tema, explorarem el multithreading i com utilitzar-lo per millorar el rendiment dels nostres jocs.

© Copyright 2024. Tots els drets reservats