resumen básico c++ vol 2

8/16/2019 Resumen Básico C++ vol 2

1/11

Ejercitario de C++Vol. 2Propiedad exclusiva de Team Compu

A pedido del público sale el volumen 2 del resumen/ejercitario que todos aman.

Solo voy a escribir sobre punteros y métodos de ordenación ya que creo que es

lo único que le falto al anterior.

Juan José Cabrera Ugarte


2/11

Team Compu - C++ Vol 2

No espere que el resumen pasado les sirviese de tanto así que vamos a intentar que

este no se quede atrás. Para empezar con punteros vamos a imaginarnos que son como el

índice de un libro: Dicen dónde está la información que buscamos pero en realidad ellos no

contienen esa información.

Punteros:

¿Se acuerdan que les había dicho que las funciones usan memorias separadas? Bueno, para

entender cómo funcionan los punteros conviene imaginarnos la memoria como una planilla de

Excel: en cada celda se puede guardar un byte de información y éstas están referidas con un

nombre o código único. Los punteros son algo complicados así que vamos a explicar cada parte

con lujo de detalle, perdón si a alguno de ustedes le molesta esto.

Operador de dirección (&):

Los punteros en la informática se llaman así porque “apuntan” a una dirección en la

memoria, pero… ¿Cómo diferencia de cuando le damos un valor a una dirección de

memoria? Para eso existe el &.

Supongamos que tenemos una variable myvar guardada en la memoria. Ahora

escribimos el siguiente código:

1 foo = &myvar;

Esto lo que hace es guardar la dirección de memoria de myvar en la variable foo. Así es

como la computadora interpreta el &, al poner en frente de una variable no le estamos

diciendo que guarde en foo el valor de la otra variable sino su ubicación.

Ahora supongamos que escribimos lo siguiente:

1

2

3

myvar = 25;

foo = &myvar;

bar = myvar;

Para simplificar la comprensión de esto vamos a suponer que la dirección de memoria

se guía por números decimales (en realidad son hexadecimales, pero eso voy a explicar

después) y entonces el código lo que haría sería algo como esto

Primero se guarda el 25 en myvar en un lugar cualquiera de la memoria (en este

ejemplo: 1776). Luego asignamos a foo la posición de myvar , por eso vemos que se

guardó 1776 y no 25. Finalmente asignamos a bar el valor de myvar .


3/11

Con el ejemplo anterior creo que se debería entender bien cómo funciona el &, así que

pasamos a lo siguiente en punteros.

Operador de indirección (*):

El nombre copie del material guía de Rojitas y me entero que se llama así, pero en

punteros esto es tanto o inclusive más importante que el operador &. Ahora sabemos

cómo guardar la dirección de memoria en una variable, pero eso no es suficiente para

considerarlo un puntero.

Manejar la ubicación en la memoria es interesante en muchas ocasiones, como vamos

a ver al aplicar en matrices y vectores, pero ¿de qué nos sirve manejar la dirección si

no podemos acceder al valor guardado en esa dirección? Para eso existe el *.

Teniendo siempre en cuenta el ejemplo anterior, escribimos el siguiente código:

1 baz = *foo;

Básicamente, el * sirve para acceder al valor guardado en la posición de memoria

ingresado. Del ejemplo anterior tenemos que foo = 1776, que es la ubicación en la

memoria de myvar . Pero al colocar el * antes de foo lo que en realidad hacemos es

guardar el valor que está en la posición 1776 de la memoria (o sea, la posición de

myvar ), que es 25, en baz. Admito que es confuso, pero por suerte esta imagen se

explica a si misma bastante bien.

Ahí ven como foo lo que hace es decir en dónde esta guardada la información nomas,

sin tener dicha información guardada en sí mismo.

Con esto debería quedar claro también cómo funciona el operador * y probablemente se

habrán dado cuenta que estos operadores se complementan entre sí: Siendo uno el que asigna

la dirección de memoria y el otro el que accede a dicha ubicación. Ahora podemos empezar a

declarar punteros.

Declaración de punteros:

Así como todas las variables, los punteros también tienen tipos (int, char, float, etc.) y

lastimosamente, al igual que en los vectores y matrices, un puntero del tipo int solo

puede apuntar a una variable de tipo int.


4/11

Si, son muy plagas, pero su sintaxis por suerte no es muy complicada:

1

2

3

int * entero;

char * letra;

double * decimal;

Creo que no hace falta explicación ya que es sólo la sintaxis de cómo se declara, así

que pasamos a lo interesante

1

2

3

4

5

6

7

8

9

1011

12

13

14

15

16

17

// ejemplo de punteros

#include

using namespace std;

int main ()

{

int x, y;

int * puntero;

puntero = &x;*puntero = 10;

puntero = &y;

*puntero = 20;

cout


5/11

1

2

3

4

5

6

78

9

10

11

12

13

14

15

16

17

// punteros en vectores

#include


int main ()

{

int v[5];int * p;

p = v; *p = 10;

p++; *p = 20;

p = &v[2]; *p = 30;

p = v + 3; *p = 40;

p = v; *(p+4) = 50;

for (int i=0; i


6/11

*p*=5: multiplica por 5 el valor de *p y lo vuelve a guardar en esa ubicación

*(p++)/=3: aumenta la posición a la que apunta y luego divide su valor entre 3

para después volver a almacenarlo en la ubicación a la que apunta

Estas y muchas otras combinaciones se pueden utilizar, si bien son un poco complicadas al

comienzo son muy útiles cuando se aplican en programas complejos.

Notas extras:

Para trabajar con puntero y matrices el funcionamiento es idéntico al de vectores, solo

que el puntero no va a tomar la matriz como tal, sino como un vector alargado con

todas las componentes una seguida de la otra.

Se puede apuntar un puntero a otro puntero, pero esto requiere una declaración un

tanto rara (tipo_del_puntero ** nombre_de_puntero;) y esto ni aparece en el material

de Rojitas, perdón Solaeche por ocupar tu memoria con información innecesaria.

Métodos de ordenación:

Ya pasamos lo que creo que era lo más complicado de entender que eran los punteros, y el

hecho de que me ocupo casi 5 páginas es un claro ejemplo de su complejidad. Ahora vamos a

ver los distintos métodos de ordenación y voy a tratar de explicar cómo funcionan, aunque

igual van a tener que memorizar al algoritmo en sí.

Método de Burbuja:

El método que posiblemente sea el más conocido, también es el método más seguro

pero el que consume más memoria y el más lento:

1

2

3

4

5

6

7

8

9

10

11

12

1314

15

16

17

18

19

20

21

22

23

24

25

2627

// metodo de burbuja

#include


int validar();

int main()

{

cout


7/11

28

29

30

31

32

33

3435

35

36

37

38

39

40

41

42

43

44

}

cout


8/11

11

12

13

14

15

16

1718

19

20

21

22

23

24

25

26

27

28

29

3031

32

33

34

35

35

36

37

38

39

40

41

4243

44

45

46

cout


9/11

Método de Selección:

Finalmente el tercer método y también el más inestable según muchos materiales,

este método es muy poco recomendado aunque capaz sea uno de los más sencillos de

entender:

1

2

3

4

5

6

7

8

9

10

11

12

1314

15

16

17

18

19

20

21

22

23

24

25

2627

28

29

30

31

32

33

34

35

35

36

37

3839

40

41

42

43

44

// metodo de seleccion

#include


int validar();

int main()

{

cout


10/11

17

18

19

20

21

22

2324

25

26

27

28

for(j=0; j


11/11

Ejercicios

1.

Escribir un programa que permita cargar un vector de N componentes, el usuario

deberá cargar el valor de N y las componentes individuales usando punteros. Luego

imprimirlo en pantalla.

2.

Calcular la traza de una matriz usando punteros y luego imprimirlo en pantalla. La

matriz podrá ser aleatoria o no, como el programador prefiera.

3. Usando punteros calcular el menor y mayor elemento de:

Un vector de 12 componentes

Una matriz de 3x4

4. Escribir un programa que, usando punteros, intercambie las componentes de las

diagonales de una matriz.

5. Usando punteros generar una matriz aleatoria de MxN componentes y luego ordenarla

por los 3 métodos estudiados.

6.

Escribir un programa que genere un vector de 5 componentes aleatorias, luegoimprima la dirección en la memoria de cada componente. Hallar una explicación del

porqué aumentan según un valor fijo y verificar si es o no independiente de los valores

del vector.

7.

Escribir un programa que imprima la transpuesta de una matriz cargada por el usuario,

se deberá implementar una función para dicho proceso.

8. Se dispone de dos vectores, maestro y esclavo, de componentes enteras y positivas e

igual número de elementos. Se deben imprimir en dos columnas adyacentes. Se

ordena el vector maestro, pero siempre que un elemento de maestro se mueva, el

elemento correspondiente de esclavo debe moverse también; es decir, cualquier

acción hecha con maestro[i] debe hacerse a esclavo[i]. Después de realizar la

ordenación se imprimen de nuevo los vectores. Escribir un programa que realice esta

tarea. Observación: Utilizar como algoritmo de ordenación, el método de inserción.

Ejercicio by Rojitas

Personalmente busque mucho y en los finales no suelen salir punteros así que con este nivel

de ejercicios creo que deberían estar preparados para lo que venga.

resumen básico c++ vol 2

Documents