Índex
 
Capítol9.zip Exercicis09.zip
Capítol 9

Els punters. Pas de paràmetres per valor i per referència.

 
  1. Els punters.
  2. Us dels punters per la comunicació entre les funcions.
    1. Pas de paràmetres per valor
    2. Pas de paràmetres per referència.
  3. Les matrius i els punters.
    1. Els vectors i els punters.
    2. Operacions amb punters.
    3. Les matrius bidimensionals i els punters.
  4. Ús dels punters per la comunicació entre les funcions.
    1. Pas d'un vector com a paràmetre.
    2. Pas d'un punter de tipus vector com a paràmetre d'una funció.
    3. Exemple de modificació de les dades d'un vector passat a una funció mitjançant un punter.
  5. Exercicis
  6. Punters a estructures.
  7. Com passar una estructura sencera a una funció.

 

9.1. Els punters.

Una variable de memòria té les dades en una certa posició de la memòria. Aquesta posició es diu l'adreça d'aquesta variable.

Una variable que té com a dada l'adreça d'una altra variable es una variable de tipus punter. És el que diem de manera més curta un punter.

Observa la figura següent i veuràs que hi ha quatre variables, Num, Lletra, Punt1 i Punt2.


La variable Punt1 apunta a la variable Num perquè te el valor 42. 
  1. La variable Num està a la adreça 42 i té el valor 25487.
  2. La variable Punt1 està a la adreça 26 i té el valor 42.
La variable Punt2 apunta a la variable Lletra perquè té el valor 84. 
  1. La variable Lletra està a la adreça 84 i té el valor 'A'
  2. La variable Punt2 està a la adreça 28 i té el valor 84

Realment aquest exemple no es dona mai ja que les adreces de memòria de las variables són molt més altes. A l'exemple següent veiem com es pot mirar l'adreça real d'una variable:


#include <stdio.h>
int main(void)
{
    int Numero;

    Numero = 25;
    printf("Valor de número %d\n",Numero);
    printf("Direcció de número %u\n",&Numero);
    printf("Direcció de número %X\n",&Numero); 

    return 0;
} 

L'operador & aplicat al nom d'una variable retorna la direcció d'aquesta variable. Així quan posem scanf("%d",&Radi) el que donem a la funció scanf és l'adreça de la variable Radi.

Un altre operador es l'asterisc * que serveix per dues coses:

  1. declarar una variable com a punter
  2. ens retorna el valor de la dada apuntada per una variable
A l'exemple següent veiem com es declara una variable de tipus punter a enter com se li assigna valor i com es poden usar les dades apuntades per aquesta variable.
int* Punt /*Declara Punt com un punter a enter*/
int Alumnes /*Declara una variable de tipus enter*/
Alumnes = 25;  
Punt = &Alumnes; /*Fa que Punt apunti a alumnes (conté la seva adreça)*/
printf("%d", *Punt); /*L'operador * fa que printf agafi la dada apuntada per Punt i escrigui 25*/

9.2. Us dels punters per la comunicació entre les funcions.

2.1 Pas de paràmetres per valor

A una funció se li pot passar com a paràmetre una variable. Això es passar-li una variable per valor.

En aquest cas tindrem duplicada la dada corresponent en dues variables de memòria, una en la funció principal i una altra en la funció.

#include <stdio.h>

int quadrat(int);

int main(void)
{ 

    num=5;
    c=quadrat(num);
    printf("El quadrat de %d és %d",num,c);
} 

int quadrat(int numero)
{
    return (numero * numero);
} 

A l'exemple veus que la dada 5 està duplicada a la variable num de la funció principal i a la variable numero de la funció quadrat.

9.2.2 Pas de paràmetres per referència.

A una funció li podem passar un punter a una variable. En aquest cas diem que passem la variable per referència. No es dupliquen les dades d'aquesta variable i la funció accedeix a la mateixa adreça d e memòria que la variable original.

Es pot accedir als valors que es troben a la memòria directament si a la funció se li passen les direccions de les variables i no les variables. Mira l'exemple següent i veuràs com es pot canviar les dades de dues variables directament a la memòria:

include <stdio.h> 

void Canvia(int *, int *); 

int main(void)
{
    int x,y; 

    printf("Escriu un número i el posar‚ a la variable x ");
    scanf("%d", &x);
    printf("Escriu un número i el posar‚ a la variable y ");
    scanf("%d", &y);
    Canvia(&x, &y);
    printf("Ara els valors de x e y són %d i %d \n",x,y);

    return 0;
} 

void Canvia(int *Punter1, int *Punter2)
{
    int auxiliar; 

    auxiliar = *Punter2;
    *Punter2 = *Punter1; 
    *Punter1 = auxiliar;
}

En aquest programa es criden tres funcions, scanf, printf i Canvia. Totes tres funcions reben les adreça de memòria de les variables x, y. Per tant a les seves declaracions tenim les variables que reben aquestes dades definides com a punters a sencers.




A la figura pots veure que
&x i &y són 42 i 84 les adreçes.
*Punt1 és 25487, és la dada.
*Punt2 és -12345, és la dada

Nota: Una funció només pot retornar un valor, però a vegades és necessari que una funció actuï sobre varies variables. La manera de fer-ho és passant les variables per referència i no per valor. 

9.3. Les matrius i els punters.

9.3.1. Els vectors i els punters.

Quan es declara un vector en la forma int Numero[10] es reserva una zona de memòria de 20 bytes per posar els elements del vector en una adreça determinada i al mateix temps es crea una constant de tipus punter a int anomenada Numero que apunta a la direcció de la primera dada del vector:

Així Numero conté l'adreça, segons la figura, de la dada 1234.




Podem copiar aquesta informació en un altre punter Punter i així disposem de dues formes de referir-nos a les dades que estan a la memòria. Observa el programa següent:

#include <stdio.h> 

int Numero[10] = {1234,532,9999,4432,12,6969,134,2442,777,588}; 

main(void)
{
    int i; 

    int *Punter; 

    printf("Els elements del vector Numero són\n");
    for(i=0;i<10;i++) printf("%5d",Numero[i]);
    printf("\n");
    printf("Hem fet ús de l'index i per referir-nos als elements de la vector\n"); 

    Punter = Numero; /*Assigna a Punter la adreça del la primer element de la vector*/
    printf("\nEls elements de la vector Numero s¢n\n");
    for(i=0;i<10;i++) 
    {
           printf("%5d",*Punter); /*Imprimeix allo que és apuntat pel Punter (*Punter)*/
           Punter++; /*Apunta al següent element de la vector*/
    }
    printf("\n");
    printf("Hem fet és d'un punter per referir-nos als elements de la vector\n");
} 

9.3.2. Operacions amb punters.

  1. Assignació. És donar una adreça a un punter.
    2.        Si Num és una variable      Punter=&Num;
       Si Nums és un vector       Punter=Nums;
  2. Incrementar un punter (punter++). Fa que el punter apunti a la següent dada del tipus especificat al punter. Això vol dir que el valor del punter s'incrementa en tants bytes com la mida de la dada mencionada.

    3. La definició d'un vector int Vector[100] fa que la paraula Vector sigui un punter, però és un punter constant, així que no es pot incrementar ni decrementar.
     

  3. Decrementar un punter (punter--). És el mateix que incrementar, fa que el punter apunti a la dada anterior del tipus especificat al punter. El valor del punter es decrementa en tants bytes com la mida de la dada mencionada.

    4.  
  4. Resta de dos punters. Normalment es fa ús entre dos punters que apunten al mateix vector i serveix per conèixer el desplaçament que hi ha entre la posició de dos elements del vector.

9.3.3. Les matrius bidimensionals i els punters.

Una matriu bidimensional és una vector de vectors. Observa l'exemple següent 
            int Nums[3][6] =    
            {
                {3,5,7,9,1,0},
                {1,1,1,1,1,1},
                {3,1,3,1,3,1}
            }
Tenim una vector de tres elements vector. Cadascun d'aquests és de sis elements.
Punter Apunta a
Nums Apunta al primer vector.
Nums[0] Apunta al primer element del vector número cero.
Nums[1] Apunta al primer element del vector número 1. 
Nums[2] Apunta al primer element del vector número 2.

Aquí podem fer assignació a dues classes de punters, un que apunti als vectors i uns altres que apuntin als elements dels vectors.

Observa la figura i veuràs que el Punter1 apunta als vectors, així si s'incrementa aquest punter farà que apunti al vector següent.

El punter2 apunta als elements del vector número 2. Si s'incrementa aquest punter es desplaça pels elements d'aquesta matriu. 

printf("Imprimeix la matriu amb els index i, j\n");
for(i=0;i<3;i++) 
{
   for(j=0;j<6;j++) printf("%5d",Nums[i][j]);
   printf("\n");
}
 Aquestes línies de programa imprimeixen la matriu sense fer ús de punters. 
int (*Punt)[6];
Punt=Nums;
printf("%d\n",(*Punt)[0]);
Punt++;
printf("%d\n",(*Punt)[0]);
Punt++;
printf("%d\n",(*Punt)[0]);
printf("Imprimeix el vector amb un 
        punter als vectors files\n");
Punt=Nums;
for(i=0;i<3;i++) 
{
   for(j=0;j<6;j++) printf("%5d",(*Punt)[j]);
   printf("\n");
   Punt++;
}
 Observa la manera en que es declaren els punters que apunten a una fila i com es pot fer-ne ús per apuntar a la la primera fila i a les files següents  
int *Punt2;
Punt2=Nums[0]; printf("%d\n",*Punt2);
Punt2++; printf("%d\n",*Punt2);
printf("Imprimeix amb un punter als 
        elements de les files\n");
for(i=0;i<3;i++) 
{
   Punt2=Nums[i];
   for(j=0;j<6;j++) 
   {
       printf("%5d",*Punt2);
           Punt2++;
   }
   printf("\n");
}
 Per últim fem ús de un punter que apunta directament als elements de les files de la matriu. 
printf("Imprimeix afegint els 
        index i i j al punter Nums\n");
for(i=0;i<3;i++) 
{
   for(j=0;j<6;j++) printf("%5d",*(*(Nums+i)+j));
   printf("\n");
}

   Nums          Apunta a la fila 0.
   Nums + 1      Apunta a la fila 1.
   Nums + 2      Apunta a la fila 2.

   **Nums          és Num[0][0]
   *(*(Nums+1)+2)   és Num[1][2]
   *(*(Nums+2)+4)   és Num[0][4]
 Encara hi ha una altra forma de fer referència als elements d'una matriu que consisteix en considerar el nom de la matriu com punter.

9.4. Ús dels punters per la comunicació entre les funcions. Els vectors.

9.4.1. Pas d'un vector com a paràmetre.

Es pot passar a una funció un vector i treballar amb elements d'aquest en la funció. Si els modifiques en la funció quedaran modificats en la funció principal, doncs el nom del vector és un punter constant. El programa següent té una funció, anomenada suma, que realitza la suma dels elements d'un vector. Aquest valor és el que retorna la funció.
#include <stdio.h> 

int Suma(int Vector[],int); 

main(void)
{
    int Numero[20],i; 

    printf("Entra 20 números\n");
    for(i=0;i<20;i++) 
    {
       printf("Entra el número %d ",i+1);
       scanf("%d",&Numero[i]);
    }
    printf("\nLa suma de tots els números és %d \n",Suma(Numero,20));
} 

int Suma(int Vector[],int Elements)
{
    int Sum,i; 

    Sum=0;
    for(i=0;i<Elements;i++) Sum += Vector[i];
    return Sum;
} 

9.4.2.Pas d'un punter de tipus vector com a paràmetre d'una funció.

També podem passar a la funció suma el punter al vector i no el vector, així tenim que treballar en la funció amb punters.
#include <stdio.h> 

int Suma(int *Vector, int); 

main(void)
{
    int Numero[20],i; 

    printf("Entra 20 números\n");
    for(i=0;i<20;i++) 
    {
       printf("Entra el número %d ",i+1);
       scanf("%d",&Numero[i]);
    }
    printf("\nLa suma de tots els números és %d \n",Suma(Numero,20));
} 

int Suma(int *Vector,int Elements)
{
    int Sum,i; 

    Sum=0;
    for(i=0;i<Elementos;i++)
    {
       Sum += *Vector;
       Vector++;
    }
    return Sum;
} 

9.4.3. Exemple de modificació de les dades d'un vector passat a una funció mitjançant un punter. .

En el programa següent es fa la suma dels elements de dos vectors. Es decalaren dos vectors Vector1 i Vector2. A més es declara el vector Resultat. Es declara la funció Suma que rep com a paràmetres els punters dels tres vectors i el número d'elements dels vectors. La funció no retorna res.
#include <stdio.h> 

void Suma(int *Vector1, int *Vector2, int *Resultat, int); 

main(void)
{
    int Numero1[10],Numero2[10],Resultat[10]; 

    int i;
    printf("Entra 20 números per a dos vectors de 10 elements cadascuna\n");
    for(i=0;i<10;i++) 
    {
       printf("Entra el número %d del vector 1",i+1);
       scanf("%d",&Numero1[i]);
       printf("Entra el número %d del vector 2",i+1);
       scanf("%d",&Numero2[i]);
    }
    Suma(Numero1,Numero2,Resultat,10);
    printf("\nEl vector suma és\n");
    for(i=0;i<20;i++) printf("%4d",Resultat[i]);
} 

void Suma(int *Vector1,int *Vector2,int *Resultat, int Elements)
{
    int Sum,i; 

    Sum=0;
    for(i=0;i<Elements;i++)
    {
       *Resultat = *Vector1 + *Vector2;
       Vector1++; Vector2++; Resultat++;
    }
}

9.5. Exercicis

  1. Escriu un programa en el que declares dues variables, les assignes valor, ens dona la adreça però has de fer ús de dos punters.

    2.  
    1. En un programa declares i assignes valor a una matriu fila de deu caràcters. Assignes un punter als elements d'aquesta matriu i escrius amb aquest punter els elements 0, 2, 4, 6 i 8 de la matriu.
    2. Fes el mateix però amb una matriu de números reals (float).
    1. Millora el programa anterior per que a més ens digui les adreces de tots els elements de la matriu. Qual és la mida de memòria d'una variable de tipus char en el nostre sistema?
    2. Fes el mateix però amb una matriu de números reals (float). Qual és la mida de memòria d'una variable de tipus float en el nostre sistema?
  2. Escriu una funció que retorni el major element d'una matriu. La funció ha de rebre un punter i el número d'elements de la matriu. Fes un programa principal que comprovi la funció.

    3.  
  3. Fes una funció igual que l'anterior però que retorni l'index del major element d'una matriu. La funció ha de rebre un punter i el número d'elements de la matriu. Fes un programa principal que comprovi la funció.

    4.  
  4. Fes una funció, anomenada SumaDeVectors, que rebi els punters a tres matrius de la mateixa mida, i també rep la mida. Amb els dos primers punters apuntes a les matrius que s'han de sumar i amb el tercer a la matriu que rebrà el resultat. Fes-ne la suma element a element. Comprova amb un senzill programa principal.

    5.  
  5. Escriu un programa que declari una matriu 3%5 i faci les següents accions:
    1. Demani els valors dels elements de la matriu a l'usuari.
    2. Imprimeixi els valors.
    3. Els multipliqui per 5 i presenti els resultats.
    4. Els multipliqui per 2 i presenti els resultats.
    Has de escriure dues funcions, la funció que presenta la matriu a la pantalla i la funció que multiplica per un valor determinat.
  6. Escriu un programa que declari una matriu 3%2 i faci les següent accions:
    1. Demani els valors dels elements de la matriu a l'usuari.
    2. Calculi e imprimeixi la mitjana aritmètica de cada fila.
    3. Calculi e imprimeixi la mitjana aritmètica de cada columna.
    4. Calculi e imprimeixi la mitjana aritmètica de tots els valors.
    5. Imprimeixi el major de tots aquest valors.
    Cada una d'aquestes accions es fa en una funció diferent. Les funcions de b), c) i d) retornen el major valor que han escrit per poder esbrinar en el programa principal qual es el major de tots.

9.6. Punters a estructures.

Imaginem que volem fer una base de dades senzilla per calcular la nòmina dels treballadors d'una empresa. Ens plantegem fer una dos estructures NomCognoms i Nòmines que es descriuen al següent segment de programa:
 
struct NomCognoms 
{
    char Nom[15]; 

    char PrimerCognom[15];
    char SegonCognom[15];
}; 

struct Nomines
{
    struct NomCognoms Nomina; 

    char Categoria[45];
    float SalariMensual;
    float IRPF;
    int HoresExtra;
    int PreuHoraExtra;
}; 

Si la empresa té dos treballadors els podem declarar per mitja d'una matriu de 2 elements e inicialitzar les dades al mateix temps:

struct Nomines Treballador[2] =
{
     {
        {"Pepe", "Gafe", "Gafotas"}, 

         "Cap de personal",
         325678, 23, 18, 2500
    },
    { 
          {"Pepita", "Grillo", "Grilleres"},
          "Secretaria del cap de personal",
          201000, 19, 18, 1500
    }
};

Així que ara a la memòria tenim les dades corresponents a Pepe i a Pepita. Ens hem d'imaginar aquestes dades disposades de forma contigua com a la figura:

Aquí veus que si es fa la instrucció Punter=Treballador fem que el punter apunti al primer registre de l'estructura i si fem Punter++ el punter es desplaça un lloc per la matriu d'estructures, es a dir que ens apunta al segon element de la matriu.

Bé, aqui tenim un programa que utilitza aquestes dades:

int main(void)
{ 
    struct Nomines *Punter; /*1*/
    printf("Adreça de memoria del registre 0: %u\n", &Treballador[0]); /*2*/
    printf("Adreça de memoria del registre 1: %u\n", &Treballador[1]); /*3*/ 

    Punter = Treballador; /*4*/ 

    printf("Adreça apuntada pel Punter: %u\n",Punter); /*5*/
    printf("Adreça apuntada pel Punter+1: %u\n",Punter+1); /*6*/ 

    printf("Punter->SalariMensual ‚s %f\n",Punter->SalariMensual); /*7*/
    printf("(*Punter).SalariMensual ‚s %f\n",(*Punter).SalariMensual); /*8*/ 

    Punter++;
    printf("El nom del segon registre és Punter->Nomina.Nom: %s\n",Punter->Nomina.Nom);
    printf("El primer cognom del segon registre és (*Punter).Nomina.PrimerCognom: %s\n", 
           (*Punter).Nomina.PrimerCognom);

    return 0;
} 

9.7. Com passar una estructura sencera a una funció.

Si fen un estudi del programa de nòmines, podem fer un estudi descendent com el següent en el que es necessiten varies funcions: 
        Menú principal amb les opcions

                0.- Acabar.
                1.- Afegir un registre.
                2.- Imprimirl-los tots.
                3.- Cercar un registre.
Així farem les funcions Afegir, ImprimirUn, ImprimirTotes i Cercar. En aquest programa es declaren les següents funcions:

struct Nomines Afegir(void);
void ImprimirUn(struct Nomines);
void ImprimirTotes(struct Nomines *,int);
void Cercar(struct Nomines *,int);
 

A la funció main veiem que es fa la distribució de tasques i es criden a les funcions necessàries.
 

int main(void) 
{
    struct Nomines Treballador[2] =
    {
        {
            {"Pepe", "Gafe", "Gafotas"}, 

             "Cap de personal",
             325678, 23, 18, 2500
        },
        { 
              {"Pepita", "Grillo", "Grilleres"},
              "Secretaria del cap de personal",
              201000, 19, 18, 1500
        }
    };

    int NumRegistres=2;
    int PresentarMenu =1;
    char Opcio='a'; 

    while (PresentarMenu)
    {
       clrscr();
       gotoxy(10,3);printf("Gestió de la base de dades de nómines");
       gotoxy(13,5);printf("0 Acaba");
       gotoxy(13,7);printf("1 Afegir un registre");
       gotoxy(13,8);printf("2 Imprimir-los tots a la pantalla");
       gotoxy(13,9);printf("3 Cercar un registre pel nom");
       Opcio='a';
       while((Opcio<'0') || (Opcio>'3')) 
       {
          gotoxy(10,11);printf("Tria una opció "); Opcio=getchar();
       }
       switch (Opcio) 
       {
          case '0' : PresentarMenu=0; break;
          case '1' : NumRegistres++;
             Treballador[NumRegistres-1]=Afegir(); /*1/
             break;
          case '2' : ImprimirTotes(Treballador,NumRegistres);break; /*2*/
          case '3' : Cercar(Treballador,NumRegistres); break; /*3/
          default : printf("\7");
       }
    }

    return 0;
} 
La funció Afegir.

Observa que està declarada de tipus struct Nomines. Així que ens ha de retornar una estructura d'aquest tipus. Ho fa mitjançant la variable Temporal que és d'aquest tipus i ens serveix per captar les dades pre pantalla com veus amb les funcions scanf.
 

struct Nomines Afegir(void)
{
    struct Nomines Temporal; 
    clrscr();
    fflush(stdin);
    gotoxy(3,3);printf("Nom: ");scanf("%[^\n]",Temporal.Nomina.Nom);
    fflush(stdin);
    gotoxy(3,4);printf("Primer cognom: ");scanf("%[^\n]",Temporal.Nomina.PrimerCognom);
    fflush(stdin);
    gotoxy(3,5);printf("Segoncognom: ");scanf("%[^\n]",Temporal.Nomina.SegonCognom);
    fflush(stdin);
    gotoxy(3,6);printf("Categoria: ");scanf("%[^\n]",Temporal.Categoria);
    gotoxy(3,7);printf("Salari mensual: ");scanf("%f",&Temporal.SalariMensual);
    gotoxy(3,8);printf("IRPF: ");scanf("%f",&Temporal.IRPF);
    gotoxy(3,9);printf("Hores extra: ");scanf("%d",&Temporal.HoresExtra);
    gotoxy(3,10);printf("Peles h. extra: ");scanf("%d",&Temporal.PreuHoraExtra); 

    return Temporal;
} 

La funció ImprimirUn

Aquesta funció rep un parámetre que es tota una variable estructura amb les seves dades, i aquesta estructura és la que utilitza per imprimer les daes a la pantalla amb les funcions printf.

void ImprimirUn(struct Nomines Registre) 
{
    gotoxy(3,3);printf("Nom: %s",Registre.Nomina.Nom); 
    gotoxy(3,4);printf("Primer cognom: %s",Registre.Nomina.PrimerCognom);
    gotoxy(3,5);printf("Segoncognom: %s",Registre.Nomina.SegonCognom);
    gotoxy(3,6);printf("Categoria: %s",Registre.Categoria);
    gotoxy(3,7);printf("Salari mensual: %f",Registre.SalariMensual);
    gotoxy(3,8);printf("IRPF%%: %f",Registre.IRPF);
    gotoxy(3,9);printf("Hores extra: %d",Registre.HoresExtra);
    gotoxy(3,10);printf("Peles h. extra: %d",Registre.PreuHoraExtra);
} 

La funció ImprimirTotes

Aquesta funció rep dos paràmetres; el punter a un registre de tipus struct Nomines i el número de registres. Observa a la línia /*1*/ com es fa ús del punter per passar un registre a la funció ImprimeUn.

void ImprimirTotes(struct Nomines *Punter,int NumeroDeRegistres)
{
    int i; 
    char Tecla;
    for(i=0;i<NumeroDeRegistres;i++) 
    {
       clrscr();
       ImprimirUn(*Punter); /*1*/
       fflush(stdin);Tecla=' ';
       while ((Tecla=getchar())!='\n');
       Punter++;
    }
} 

La funció Cercar

De la mateixa manera que la funció ImprimirTotes aquesta funció rep dos paràmetres; el punter a un registre de tipus struct Nomines i el número de registres.

void Cercar(struct Nomines *Punter,int NumeroDeRegistres)
{
    int i; 
    char NomEntrat[45];
    char NomRegistre[45];
    char Tecla; 

    clrscr(); 

    printf("Entra un nom amb el format PCognom;Scognom;Nom\n");
    fflush(stdin);scanf("%s",NomEntrat); 

    for(i=0;i<NumeroDeRegistres;i++)
    {
       strcpy(NomRegistre,(*Punter).Nomina.PrimerCognom); //En aquestes línies
       strcat(NomRegistre,";"); //es construeix una sola
       strcat(NomRegistre,(*Punter).Nomina.SegonCognom); //cadena de caràcters per
       strcat(NomRegistre,";"); //posar-hi el nom complet
       strcat(NomRegistre,(*Punter).Nomina.Nom); //del registre apuntat en 
                                                                               //aquest momet.
       if (strstr(NomRegistre,NomEntrat) != NULL) 
       {
          ImprimirUn(*Punter);
          printf("\nPrem Return ");
          fflush(stdin);
          Tecla = ' ';
          while((Tecla=getchar())!='\n');
        }
        Punter++;
    }
} 

Es fa us de les funcions strcat, strcopy i strstr del conjunt de funcions string.h. Fan el següent:
strcat(cadena1,cadena2) Afegeix a cadena1 el contingut de cadena2.
strcopy(cadena1,cadena2) Substitueix el contingut de cadena1 pel de cadena2.
strsstr(cadena1,cadena2) Cerca el contingut de cadena2 dins del contingut de cadena1. Si el troba retorna un punter al lloc on es troba cadena2 dins de la cadena1. Si no el troba retorna NULL.