Beruflich Dokumente
Kultur Dokumente
VECTORES
Un vector, también llamado array(arreglo) unidimensional, es una estructura de datos
que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de
memoria juntos, uno despues de otro. A este grupo de elementos se les identifica por
un mismo nombre y la posición en la que se encuentran. La primera posición del array
es la posición 0.
Podríamos agrupar en un array una serie de elementos de tipo enteros, flotantes,
caracteres, objetos, etc. Crear un vector en c++ es sencillo, seguimos la siguiente
sintaxix: Tipo nombre[tamanyo];
Ejm:
01 #include <iostream>
02 using namespace std;
03
04 int main()
05 {
06 int dim;
07 cout << "Ingresa la dimension del vector" << endl;
08 cin >> dim; // Supongamos que ingrese 10
09 int vector[dim]; // mi vector es de tamanyo 10
10
11 for(int i=0;i < dim;i++){
12 vector[i] = i * 10;
13 cout << vector[i] << " ";
14 }
15
16 return 0;
17 }
La salida del programa mostrará: 0 10 20 30 40 50 60 70 80 90
Fàcil verdad? Bien ahora creen 2 o más vectores y empiecen a hacer funciones básicas
como sumar, restar, buscar, ordenar, moda, etc que ayudan mucho a ir desarrollando
la lógica. No vale copiar y pegar, mejor es practicar, practicar y practicar.
Aquí una función simple para sumar 2 vectores a y b y poner el resultado en un tercer
vector c
01 #include <iostream>
02 using namespace std;
03
04 void sumar(int a[], int b[], int c[],int dim){
05 for (int i=0; i<dim; i++) {
06 c[i]=a[i] + b[i];
07 }
08 }
09
10 void imprimir(int v[],int dim)
11 {
12 for(int i=0;i<dim;i++){
13 cout << v[i] << " ";
14 }
15 cout << endl << endl;
16 }
17
18 int main()
19 {
20 int dim;
21 cout << "Ingresa la dimension" << endl;
22 cin >> dim;
23
24 int a[dim];
25 int b[dim];
26 int c[dim];
27
28 for(int i=0;i<dim;i++){
29 a[i] = i * 10;
30 b[i] = i * 5;
31 }
32
33 cout << "Vector A " << endl;
34 imprimir(a,dim);
35
36 cout << "Vector B " << endl;
37 imprimir(b,dim);
38
39 sumar(a,b,c,dim);
40 cout << "Vector C " << endl;
41
42 imprimir(c,dim);
43 return 0;
44 }
Este programa me botaría (si ingreso una dimensión de 10):
Vector A
0 10 20 30 40 50 60 70 80 90
VECTOR B
0 5 10 15 20 25 30 35 40 45
VECTOR C
0 15 30 45 60 75 90 105 120 135
Entonces para tomar en cuenta:
Bueno y para recorrer una matriz podemos usar igualmente un bucle. En este caso 2
for
1 for(int i=0;i<fils;i++){
2 for(int j=0;j<cols;j++){
3 matriz[i][j] = i % j;
4 }
5}
PUNTEROS
El valor de todas las variales que manejamos en nuestros programas se almacenan en
memoria y tienen una dirección. Un puntero es una variable especial que apunta a la
dirección de memoria de una variable. El puntero tiene a su vez su propia dirección.
Todas estas direcciones tienen un formato hexadecimal.
Los punteros son herramientas muy poderosas con muchas utilidades y enormes
ventajas como veremos más adelante. A grandes rasgos, un puntero me permite
desplazarme en la memoria, apuntar, redireccionar a ciertas variables, funciones,
métodos, objetos sin necesidad de mover grandes bloques de datos, lo cual nos ahorra
muchísimo el consumo de memoria en los programas.
1 int *var; //Un puntero llamado var que podra apuntar a cualquier variable
de tipo entero.
2 char *u;//puntero de tipo char
3 Persona *per;//puntero de tipo persona
Para determinar,asignar la dirección de una variable en c++, se usa el operador & y
para obtener el contenido de un puntero utilizamos el operador * Ejem:
1 int a;//entero
2 int *b;//puntero a entero
3 a = 20;//a tiene 20
4 b=&a;//asigno la direccion de a al puntero b
5
6 cout << b << endl; // imprira la direccion de memoria de a;
7 cout << *b;// imprimira 20, osea el contenido de a
Ahora analicemos las siguientes instrucciones y veamos como las variables van
cambiando de valor en tiempo de ejecución:
01 #include <iostream>
02 using namespace std;
03 int main () {
04 int a=10;
05 int b=20;
06 int *p,*p2;//punteros de tipo entero
07
08 cout << "ANTES" << endl;
09 cout << "Variable a = " << a << endl;
10
11 cout << "Direccion de a = " << &a << endl << endl;
12
37 cout << "Contenido de p2 (BASURA) = " << *p2 << endl;//tiene basura
al principio, podria inicializar con *p2=0
38 cout << "Direccion de p2 = " << &p2 << endl << endl;
39
40 p2 = p;//el contenido de p es asignado al contenido de p2
41 *p2 +=15;//incremento 15 al contenido de p2
42
ARITMÉTICA DE PUNTEROS
En las ultimas sentencias del programa anterior:
p++;
cout << *p;
Pueden visualizar que estoy incrementando el puntero p en 1. Esto quiere decir que el
puntero se desplazara 4 bytes en memoria (en este caso por ser entero) y entonces
apuntara a otra direccion. Por eso es que el nuevo contenido de p es basura o bueno el
contenido de lo que tiene esa nueva direccion a la que apunta.
1 char c;
2 char *d;
3
4 d= &c;//asigno la direccion de c a d
5 c='u';//asigno el valor u a mi variable c
6 c--;//desplazo una posicion a c
7 cout << *d;//
No Imprimira ‘u’ porque fijense que desplazé c en sentido negativo 1 byte (los char
ocupan a 1 byte). Es decir, que si d estaba apuntado a una direccion como por ejemplo
0x22ff99, despues del c– estara apuntando a algo como 0x22ff98
01 int a=15;
02 int *p;
03
04 double *q;
05 void *r;
06
p = a; //No puedo hacer esto porque estoy asignando una variable a un
07
puntero y un puntero es una direccion.
p = &50; // 50 es un valor constante en este caso y no una variable,por
08
lo tanto no tiene direccion
09 p = &(a+1); //una expresion no tiene direccion
10 p = 30;//igual que el primer error, 30 es un entero.
11 &a = p;//no puedo cambiar la direccion de una variable
12 p = q;//p es puntero de tipo entero y q de tipo double
Un puntero de tipo void, es un puntero al cual le podemos asignar cualquier tipo de
puntero. Por lo tanto si podriamos hacer esto:
r = p;
VECTORES Y PUNTEROS
Cuando declaramos un vector int v[10];El nombre del vector, o sea v, es un puntero al
primer elemento del vector, es decir a v[0].Entonces como un vector es un puntero al
primer elemento del mismo, también podríamos hacer aritmética de punteros con el
vector.
1 (v+1) ;//apuntara a v[1];
2 *(v+5);//me refiero al contenido de v[5]
3
4 //Y también a los punteros les puedo poner índices:
5
6 int *p; //puntero de tipo entero
7 p = &v[0];//p apunta a la direccion del vector v[0] o tambien a v. p = v
p[8] = 80; //le asigno el valor 80 al puntero en la posicion 8, es decir
8
a v[8]
VECTORES DINÁMICOS
Lo que vimos en el inicio de este post, son vectores estáticos, puesto que tienen una
cantidad fija de memoria asignada y tamaño definido que no podemos modificarlo. Sin
embargo, un vector podría tener una cantidad variable de datos, a este se le llama un
vector dinámico.
Un simple ejem:
01 #include <iostream>
02 using namespace std;
03
04 int main()
05 {
06 int *pv;
07 int dim;
08
09 cout << "Ingresa el tamanyo del vector" << endl;
10 cin >>dim;
11 pv = new int[dim];
12
13 for(int i=0;i<dim;i++){
14 pv[i] = i * i;
15 cout << pv[i] << " ";
16 }
17
18 delete[] pv;
19 return 0;
20 }
MATRICES Y PUNTEROS
Supongamos que se declaró una matriz int m[5][5]
*p;//contenido de m[0],el cual apunta al primer elemento de ese vector, es decir, m[0]
[0]
7
8 //En conclusión:
9 p[i][j] = *(*(p+i)+j) = *(pm[i]+j)
MATRICES DINÁMICAS
Para crear una matriz dinámica debemos de crear un doble puntero int **pm y samos
al igual que los vectores el operador new para reservar memoria y delete para liberar.
Primero tenemos que crear el vector que contendrá a otros vectores especificando el
numero de vectores que tendra este vector principal. Ejem:
3 pm[i] = new int [cols];//para crear los vectores dentro del vector
principal
4}
Ahora sí vamos al grano y veamos un simple programa que crea una matriz dinámica,
asigna valores, muestra el contenido de cada uno de los elementos los elementos así
como sus direcciones de memoria.
01 #include <iostream>
02 using namespace std;
03
04 int main()
05 {
06 int **pm;//puntero a una matriz
07 int fils,cols;
08
09 cout << "Ingresa el nro de filas: ";
10 cin >>fils;
11
12 cout << endl;
13 cout << "Ingresa el nro de columnas: ";
14 cin >>cols;
15
16 pm = new int* [fils];
17 for(int i=0;i<fils;i++){
18 pm[i] = new int [cols];
19 }
20
21 cout << "Elementos de la Matriz con sus direcciones" << endl;
22 for(int i=0;i<fils;i++){
23 for(int j=0;j<cols;j++){
24 pm[i][j] = i + j;
25 cout << pm[i][j] << "--> ";
26 cout << &pm[i][j] << " ";
27 }
28 cout << endl;
29 }
30 cout << endl;
31
32 cout << "La matriz con aritmetica de punteros" << endl;
33 for(int i=0;i<fils;i++){
34 for(int j=0;j<cols;j++){
35 *(*(pm+i)+j) = i + j;//aritmetica de punteros
36 cout << *(*(pm+i)+j) << "-->";
37 cout << &pm[i][j] << " ";
38 }
39 cout << endl;
40 }
41
42 for(int i=0;i<fils;i++){
43 delete[] pm[i];//elimino cada vector de la matriz
44 }
45 delete[] pm;//elimino el vector principal
46 return 0;
47 }
La salida del programa: