presentación.pdf

(1)

Introducci´on. Apuntadores

Arreglos y Apuntadores.

Liliana Romero.

(2)

Definici´on

Los arreglos son un conjunto de variables que tienen el mismo tipo y que se identifican con el mismo nombre.

(3)

Definici´on

(4)

Definici´on

(5)

Arreglos unidimensionales.

Conjunto de variables del mismo tipo, identificadas con el mismo nombre, ordenado mediante el conjunto de ´ındices :

{0,1, ...,n}

0 es el ´ındice de la primera variable contenida en el arreglo

n es el ´ındice de la ´ultima variable contenida en el arreglo

(6)

{0,1, ...,n}

(7)

{0,1, ...,n}

(8)

{0,1, ...,n}

(9)

Declaraci´on de arreglos unidimensionales:

Tipo_de_las_variables Nombre[Tama~no del arreglo];

Ejemplo

double velocidad[50]; int X[30];

(10)

Declaraci´on de arreglos unidimensionales:

Tipo_de_las_variables Nombre[Tama~no del arreglo];

Ejemplo

double velocidad[50]; int X[30];

(11)

Arreglos unidimensionales tipo char

Las palabras se forman con un conjunto finito de caracteres.

Podemos utilizar arreglos unidimensionales tipochar para construir

(12)

Arreglos unidimensionales tipo char

Las palabras se forman con un conjunto finito de caracteres.

Podemos utilizar arreglos unidimensionales tipochar para construir

(13)

Introducci´on. Apuntadores Programa que escribeClase.

#include<stdio.h>

int main() {

char N[5]; N[0]=’C’; N[1]=’l’; N[2]=’a’; N[3]=’s’; N[4]=’e’;

for(int i=0; i<5;i++) printf("%c",N[i]); printf("\n\n");

(14)

¿ Y si queremos pedir por ejemplo el nombre del usuario?

Pedirlo caracter por caracter?

%

Pedirle que al usuario que digite todo el nombre?X

instrucci´ongets(·)

(15)

Pedirlo caracter por caracter?%

(16)

Pedirle que al usuario que digite todo el nombre?

X

(17)

(18)

(19)

#include<stdio.h>

int main() {

char n[100];

printf("Digite su nombre:\n\n"); gets(n);

printf("\nHola %s\n\n",n); return 0;

}

Si el usuario digitaJuan L´opez

(20)

#include<stdio.h>

int main() {

char n[100];

}

(21)

#include<stdio.h>

int main() {

char n[100];

}

(22)

Direcci´on de memoria

Una forma com´un de describir la memoria principal de un

ordenador es como una colecci´on de celdas que almacenan datos e

instrucciones. Cada celda est´a identificada un´ıvocamente por un

número (hexadecimal), dicho número se conoce como dirección de

memoria.

Sistema hexadecimal

S ={0,1,2,3,4,5,6,7,8,9,A,B,C,D,E}

A= 10, B= 11, C = 12, D= 13, E = 14, F = 15.

Ejemplo

3EA0 = 3×163+E×162+A×161+ 0×160

(23)

Introducci´on. Apuntadores Direcci´on de memoria

memoria.

Sistema hexadecimal

S ={0,1,2,3,4,5,6,7,8,9,A,B,C,D,E}

A= 10, B= 11, C = 12, D= 13, E = 14, F = 15.

Ejemplo

3EA0 = 3×163+E×162+A×161+ 0×160

(24)

memoria.

Sistema hexadecimal

S ={0,1,2,3,4,5,6,7,8,9,A,B,C,D,E}

A= 10, B= 11, C = 12, D= 13, E = 14, F = 15.

Ejemplo

3EA0 = 3×163+E×162+A×161+ 0×160

(25)

memoria.

Sistema hexadecimal

S ={0,1,2,3,4,5,6,7,8,9,A,B,C,D,E}

A= 10, B= 11, C = 12, D= 13, E = 14, F = 15.

Ejemplo

3EA0 = 3×163+E×162+A×161+ 0×160

(26)

Definici´on

Un apuntador (o puntero) es una variable cuyo valor es la direcci´on

de memoria de otra variable. Se dice que un apuntador “apunta” a

la variable cuyo valor se almacena a partir de la direcci´on de

memoria que contiene el apuntador.

Ejemplo

Si un apuntador p almacena la direcci´on de una variable x , se dice

(27)

Referenciaci´on

Es la obtenci´on de la direcci´on de una variable. En C y C++ esto

se hace a trav´es del operador ’&’.

#include<iostream> using namespace std; int main()

{

int x=25;

cout<<"La direcci´on de x es:"<<&x<<endl; return 0;

(28)

Referenciaci´on

{

int x=25;

(29)

Referenciaci´on

{

int x=25;

(30)

Al igual que el resto de las variables los apuntadores se enlazan a tipos de datos especificos (apuntadores a variables de cierto tipo), de manera que a un apuntador solo se le pueden asignar direcciones de variables del tipo especificado en la declaraci´on del apuntador

int *p1; float *p2; int x;

(31)

(32)

(33)

Para visualizar con mayor facilidad la relaci´on entre apuntador y el arreglo, debemos decir que el nombre del arreglo es en realidad un apuntador que apunta a la primera componente del arreglo.

double X[10];

Si extraigo el valor que est´a contenido la direcci´on en la cual se ubica el arreglo X.

double p=*X;

(34)

double X[10];

double p=*X;

(35)

double X[10];

double p=*X;

(36)

double X[10];

double p=*X;

(37)

double X[10];

double p=*X;

(38)

double X[10];

(39)

#include<stdio.h>

int main() {

double X[3]; X[0]=5; X[1]=7; X[2]=11;

printf("\nX[0] almacena el valor %lf, en la dirección %p",*X,&X[0]); printf("\nX[1] almacena el valor %lf, en la dirección %p",*(X+1),&X[1]); printf("\nX[2] almacena el valor %lf, en la dirección %p",*(X+2),&X[2]);

(40)

#include<stdio.h>

int main() {

double X[3]; X[0]=5; X[1]=7; X[2]=11;

printf("\nX[0] almacena el valor %lf, en la dirección %p",*X,&X[0]); printf("\nX[1] almacena el valor %lf, en la dirección %p",*(X+1),&X[1]); printf("\nX[2] almacena el valor %lf, en la dirección %p",*(X+2),&X[2]);

(41)

Ahora que sabemos que el arreglo es un puntero a la primera

posici´on, se puede decir que el nombre del arreglo nos permite

indexar componentes en el apuntador de manera analoga a como se hace en el arreglo. Es decir, solo debemos cambiar la declaraci´on

de arreglo a declaraci´on de apuntador en nuestros programas.

¿ Como l´ımito el tama˜no del vector si lo declaro como un

(42)

(43)

(44)

Asignaci´on de memoria

En las declaraciones de arreglos unidimensionales que hemos visto, se puede observar que:

Se puede usar el n´umero exacto de componentes del arreglo.

Se pueden dejar componentes en blanco.

Observaci´on: Cuando creamos un vector y no utilizamos toda su

capacidad, estamos desperdiciando la memoria del computador ya que se ocupa algo que no ser´a de utilidad.

(45)

(46)

(47)

(48)

(49)

Comandonew

Con este comando declaramos el n´umero de variables que

contendrá nuestro arreglo. As´ı la declaración de un arreglo via apuntador se hará de la siguiente manera:

double *X

X=new double[10]

La primera l´ınea nos permite apuntar aX, mientras la segunda

l´ınea nos permite definir el n´umero de componentes de los cuales

dispondremos en nuestro arreglo. En este caso, como el n´umero de

componentes del arreglo es fijo, diremos que se realiza asignaci´on

(50)

Comandonew

double *X

X=new double[10]

(51)

Comandonew

double *X

X=new double[10]

(52)

Comandonew

double *X

X=new double[10]

(53)

Si la declaraci´on se realiza de la siguiente manera:

double *X;

X=new double[n];

Donden es dado por el usuario, diremos que se realiza asignaci´on

din´amica de memoria, ya que la asignaci´on de memoria se realiza

(54)

double *X;

X=new double[n];

(55)

double *X;

X=new double[n];

(56)

double *X;

X=new double[n];

(57)

Liberaci´on de memoria

C++ tambi´en nos permite liberar la memoria una vez no

necesitemos la informaci´on almacenada, mediante el comando

delete.

Si deseamos borrar el espacio asignado para el vectorX de tama˜no

n, utilizamos la instrucci´on:

(58)

delete.

(59)

delete.

(60)

delete.

(61)

Arreglos en funciones

Para poder utilizar un arreglo como par´ametro de una funci´on,

debemos anunciarle al compilador que el par´ametro es, en efecto,

un arreglo; existen diversas maneras de hacerlo, en particular la

m´as com´un es aplicando el concepto apuntador con el cual

(62)

Introducci´on. Apuntadores #include<stdio.h>

void lectura(double X[],int n); void escritura(double X[],int n);

int main() { int n;

printf("Digite la longitud del arreglo\n\n"); scanf("%d",&n); double X[n]; lectura(X,n); escritura(X,n); return 0; }

/*Funci´on lectura*/

void lectura(double X[],int n) { for(int i=1;i<=n;i++) { printf("\nX[%d]= ",i); scanf("%lf",&X[i-1]); } }

(63)

#include<stdio.h>

void lectura(double *X,int n); void escritura(double *X,int n);

int main() { int n;

printf("Digite la longitud del arreglo\n\n"); scanf("%d",&n); double *X; X=new double[n]; lectura(X,n); escritura(X,n); return 0; }

/*Funci´on lectura*/ void lectura(double *X,int n) { for(int i=1;i<=n;i++) { printf("\nX[%d]= ",i); scanf("%lf",&X[i-1]); } }

/*Funci´on escritura*/ void escritura(double *X,int n) {

for(int j=1;j<=n;j++) {

printf("\nX[%d]= %lf ",j,X[j-1]); }

(64)

Introducci´on. Apuntadores #include<stdio.h>

void lectura(double *X,int n); void escritura(double *X,int n);

int main() { int n;

printf("Digite la longitud del arreglo\n\n"); scanf("%d",&n); double *X; X=new double[n]; lectura(X,n); escritura(X,n); return 0; }

(65)

Arreglos bidimensionales

Los arreglos bidimensionales pueden ser vistos como matrices En la declaraci´on se debe tener en cuenta el n´umero de filas y comlumnas que debe tener dicha matriz

double X[5][5];

La asignaci´on se hace componente a componente

X[2][4]=5;

(66)

double X[5][5];

X[2][4]=5;

(67)

Los arreglos bidimensionales pueden ser vistos como matrices

En la declaraci´on se debe tener en cuenta el n´umero de filas y comlumnas que debe tener dicha matriz

double X[5][5];

X[2][4]=5;

(68)

double X[5][5];

X[2][4]=5;

(69)

double X[5][5];

X[2][4]=5;

(70)

double X[5][5];

X[2][4]=5;

(71)

double X[5][5];

X[2][4]=5;

(72)

Si queremos que el usuario sea el que digite los valores de cada t´ermino de la matriz, usamos la instrucci´on:

scanf("%lf",&X[i][j]);

Sin embargo, para el trabajo desde funciones se recomienda el uso de apuntadores ya que la declaraci´on ilimitada doubleX[][] no

puede ser utilizada como par´ametro de una funci´on, el paso como

(73)

(74)

(75)

(76)

Funci´on de lectura y escritura de matrices

void lecturaMatriz(double X[][10], int m, int n) {

for(int i=0; i<m; i++) {

for(int j=0; j<n; j++) {

printf("X[%d][%d] = ",i+1,j+1); scanf("%lf", &X[i][j]); }

} }

//---void escrituraMatriz(double X[][10], int m, int n) {

for(int i =0;i<m; i++) {

for(int j=0; j<n; j++) printf("%lf\t",X[i][j]); printf("\n");

}

(77)

Funci´on de lectura y escritura de matrices

void lecturaMatriz(double X[][10], int m, int n) {

for(int i=0; i<m; i++) {

for(int j=0; j<n; j++) {

printf("X[%d][%d] = ",i+1,j+1); scanf("%lf", &X[i][j]); }

} }

//---void escrituraMatriz(double X[][10], int m, int n) {

for(int i =0;i<m; i++) {

for(int j=0; j<n; j++) printf("%lf\t",X[i][j]); printf("\n");

}

(78)

Matrices con apuntador

Si queremos un arreglo cuyas componentes son arreglos (es decir

una matiz), lo m´as natural ser´ıa pensar en un apuntador sobre un

apuntador.

Si tenemos un apuntador a apuntador, el primer apuntador

contiene la direcci´on del segundo apuntador, el cual apunta a la

(79)

apuntador.

(80)

apuntador.

(81)

Para recordar

La construcci´on de arreglos via apuntador no nos permite inicializar

mientras declaramos, es decir, no podemos definir el tama˜no del

arreglo en el momento de declarar el apuntador, requerimos del

comandonew para poder realizar dicha labor ya que la asignaci´on

(82)

Para recordar

La construcci´on de arreglos via apuntador no nos permite inicializar

mientras declaramos, es decir, no podemos definir el tama˜no del

arreglo en el momento de declarar el apuntador, requerimos del

comandonew para poder realizar dicha labor ya que la asignaci´on

(83)

Funci´on que permite declarar una matrizn×n

double **creaMatriz(int m,int n) {

// DEVUELVE LA MATRIZ CON SUS VALORES ALMACENADOS double **p;

int i;

p = new double *[m] ; if( p == NULL ) return( NULL ); for( i=0; i<m; i++) { p[i] = new double[n];

if( p[i] == NULL ) return( NULL ); }

return p; }

La condicion p==NULL, indica que la direcci´on de la variable

no puede ser nula.

El nombre de la funci´on tipo double tiene antepuestos 2

asteriscos.

(84)

Funci´on que permite declarar una matriz n×n

double **creaMatriz(int m,int n) {

// DEVUELVE LA MATRIZ CON SUS VALORES ALMACENADOS double **p;

int i;

p = new double *[m] ; if( p == NULL ) return( NULL ); for( i=0; i<m; i++) { p[i] = new double[n];

if( p[i] == NULL ) return( NULL ); }

return p; }

La condicion p==NULL, indica que la direcci´on de la variable

no puede ser nula.

El nombre de la funci´on tipo double tiene antepuestos 2

(85)

Funci´on que permite construir la matriz “identidad” de cualquier tama˜no

void identidad(double **X, int m, int n) {

for(int i=0;i<m;i++) {

for(int j=0;j<n;j++) {

if(i==j) X[i][j]=1; // 1 en la diagonal if(i!=j) X[i][j]=0; // 0 fuera de la diagonal }

(86)

Funci´on que retorna 0 si dos matrices son distintas y 1 si son iguales

int igualdad(double **X,double **Y,int m, int n) {

if(X[i][j]!=Y[i][j]) return 0; }

}

(87)

Funci´on que retorna 0 si dos matrices son distintas y 1 si son iguales

int igualdad(double **X,double **Y,int m, int n) {

if(X[i][j]!=Y[i][j]) return 0; }

}

(88)

M´etodo Burbuja

M´etodo que sirve para ordenar un conjunto de n´umeros.

Supongamos que tenemos un vectorx = (x1,x2, ...xn)

Primera iteraci´on: Se revisa six1 yx2 est´an ordenados, si no

lo están se intercambian. después se revisa six2 yx3 están

ordenados, si no lo están se intercambian... Finalmente, se revisa si xn−1 yxn están ordenados, si no lo están se

intercambia.

Segunda iteraci´on: Se realiza un proceso semejante, pero la

´

ultima pareja que se compara es xn−2 yxn−1

Al final de esta segunda pasada los dos ultimos elementos est´an en sus posiciones definitivas.

...

n−1-´esima iteraci´on: Se realiza un proceso semejante, pero la ´

(89)

Introducci´on. Apuntadores M´etodo Burbuja

intercambia.

´

...

(90)

intercambia.

´

...

(91)

intercambia.

´

...

(92)

intercambia.

´

...

(93)

intercambia.

´

...

(94)

intercambia.

´

(95)

intercambia.

´

...