El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Plantilles

Següent ►
►

Les plantilles en C++ són una característica poderosa que permet escriure codi generat per a múltiples tipus de dades sense duplicar el codi. Les plantilles es poden utilitzar per a funcions i classes, i són una part fonamental de la programació genèrica en C++.

Continguts

  1. Introducció a les Plantilles
  2. Plantilles de Funció
  3. Plantilles de Classe
  4. Plantilles amb Múltiples Paràmetres
  5. Plantilles Especialitzades
  6. Exercicis Pràctics

Introducció a les Plantilles

Les plantilles permeten definir funcions o classes que poden operar amb qualsevol tipus de dades. Això es fa utilitzant paràmetres de tipus, que són substituïts per tipus concrets quan es crea una instància de la plantilla.

Exemple Bàsic

#include <iostream>
using namespace std;

template <typename T>
T sumar(T a, T b) {
    return a + b;
}

int main() {
    cout << sumar(3, 4) << endl;       // Sortida: 7
    cout << sumar(3.5, 4.5) << endl;   // Sortida: 8.0
    return 0;
}

En aquest exemple, sumar és una funció plantilla que pot sumar dos valors de qualsevol tipus que suporti l'operador +.

Plantilles de Funció

Les plantilles de funció permeten definir funcions genèriques. La sintaxi bàsica és:

template <typename T>
retorn funció(T paràmetre) {
    // cos de la funció
}

Exemple

template <typename T>
T multiplicar(T a, T b) {
    return a * b;
}

int main() {
    cout << multiplicar(2, 3) << endl;       // Sortida: 6
    cout << multiplicar(2.5, 3.5) << endl;   // Sortida: 8.75
    return 0;
}

Plantilles de Classe

Les plantilles de classe permeten definir classes genèriques. La sintaxi bàsica és:

template <typename T>
class NomClasse {
    T membre;
public:
    NomClasse(T valor) : membre(valor) {}
    T obtenirMembre() { return membre; }
};

Exemple

template <typename T>
class Caixa {
    T contingut;
public:
    Caixa(T contingut) : contingut(contingut) {}
    T obtenirContingut() { return contingut; }
};

int main() {
    Caixa<int> caixaEntera(123);
    Caixa<string> caixaString("Hola");

    cout << caixaEntera.obtenirContingut() << endl;  // Sortida: 123
    cout << caixaString.obtenirContingut() << endl;  // Sortida: Hola
    return 0;
}

Plantilles amb Múltiples Paràmetres

Les plantilles poden tenir múltiples paràmetres de tipus.

Exemple

template <typename T, typename U>
class Parell {
    T primer;
    U segon;
public:
    Parell(T primer, U segon) : primer(primer), segon(segon) {}
    T obtenirPrimer() { return primer; }
    U obtenirSegon() { return segon; }
};

int main() {
    Parell<int, double> parell(1, 2.5);
    cout << parell.obtenirPrimer() << endl;  // Sortida: 1
    cout << parell.obtenirSegon() << endl;   // Sortida: 2.5
    return 0;
}

Plantilles Especialitzades

La especialització de plantilles permet definir versions específiques d'una plantilla per a tipus concrets.

Exemple

template <typename T>
class TipusEspecial {
public:
    void mostrar() {
        cout << "General" << endl;
    }
};

template <>
class TipusEspecial<int> {
public:
    void mostrar() {
        cout << "Especialitzat per a int" << endl;
    }
};

int main() {
    TipusEspecial<double> obj1;
    TipusEspecial<int> obj2;

    obj1.mostrar();  // Sortida: General
    obj2.mostrar();  // Sortida: Especialitzat per a int
    return 0;
}

Exercicis Pràctics

Exercici 1

Crea una funció plantilla maxim que retorni el valor màxim entre dos arguments.

template <typename T>
T maxim(T a, T b) {
    return (a > b) ? a : b;
}

int main() {
    cout << maxim(10, 20) << endl;       // Sortida: 20
    cout << maxim(3.5, 2.5) << endl;     // Sortida: 3.5
    return 0;
}

Exercici 2

Crea una classe plantilla Parell que emmagatzemi dos valors de tipus diferents i proporcioni mètodes per obtenir-los.

template <typename T, typename U>
class Parell {
    T primer;
    U segon;
public:
    Parell(T primer, U segon) : primer(primer), segon(segon) {}
    T obtenirPrimer() { return primer; }
    U obtenirSegon() { return segon; }
};

int main() {
    Parell<int, double> parell(1, 2.5);
    cout << parell.obtenirPrimer() << endl;  // Sortida: 1
    cout << parell.obtenirSegon() << endl;   // Sortida: 2.5
    return 0;
}

Conclusió

Les plantilles són una eina poderosa en C++ que permeten escriure codi genèric i reutilitzable. Hem vist com crear plantilles de funció i de classe, com utilitzar múltiples paràmetres de tipus i com especialitzar plantilles per a tipus concrets. Practicar amb plantilles t'ajudarà a comprendre millor la programació genèrica i a escriure codi més flexible i eficient.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats