QT Capitulo 04

Programación C++ con las Librerías QT sobre entorno linux
CAPITULO IV
I. CONTENIDO
CAPÍTULO No. 4: Estructura de control de flujos Duración: 4 Hrs
Temas Habilidades
Al finalizar el capítulo, el alumno podrá:
• Punteros Dinámicos • Aplicación de punteros
• Estructura de datos • Definir estructuras de datos
•
II. PUNTEROS DINAMICOS
Los punteros son variables que se utilizan para almacenar direcciones de memoria que
fueron asignadas a variables en las que se almacenan datos de distinto tipo.
Cada uno de los espacios de memoria cuenta con una dirección para identificarlo, esta
dirección es por lo general un número en representación hexadecimal.
Una vector o matriz es una estructura de datos formada por un conjunto de elementos
del mismo tipo; en la definición de estas estrructuras de datos se debe de indicar el
tamaño o número de elementos que van a contener, haciendo constante el tamaño de
estas estructuras.
Capitulo IV Pág. 1
➢ VECTORES DINAMICOS, por medio de los punteros podemos crear arreglos o
vectores dinámicos, es decir, un array al cual se le define su tamaño o capacidad
durante la ejecución del código y no antes, lo cual nos permite definirle el tamaño
deseado por el usuario.
Para usar vectores dinámicos necesitamos gestionar memoria dinámica. Si bien es

cierto que esto trae enormes ventajas, el hacer un mal uso de la memoria dinámica
nos podría traer problemas desastrosos, por eso es importante que cuando creemos
vectores dinámicos también liberemos la memoria utilizada cuando ya no necesitemos
usar mas el vector creado
Los operadores que se deben de usar son el new y delete, el operador new sirve para
reservar memoria dinámica, mientras que el operador delete se usa para liberar la
memoria dinámica reservada con new.
La memoria del computador se divide en sectores, cada sector tiene un uso particular,
de dicha división de la memoria podemos indicar:
✓ Stack (pila), es el sector donde se crean todas las variables y funciones que
están definidas antes de la compilación del programa y tiene un ámbito de
ejecución local. La gestión de este espacio de memoria la hace el sistema
operativo.
Capitulo IV Pág. 2
✓ Head (monton), es el sector donde se crean las variables que se crean en
memoria en tiempo de ejecución. El tamaño de este segmento no está
predefinido, va variando. Crece hacia a arriba, en el mismo sentido que las
direcciones de memoria.
✓ Data, sección que almacena las variables globales incializadas en el programa.
✓ Text, sección donde se almacen todas las instrucciones en código de maquina
que componen el programa que se está ejecutando.
El espacio de memoria que hemos reservado con new tendrá vida hasta que finalize la
ejecución del programa o cuando liberemos ese espacio con delete. Estas variables
dinámicas se crean en el espacio de memoria llamada head.
Siempre es recomendable liberar memoria para posteriormente no tener problemas

con excesivo consumo de memoria.
int *p;
int dim;
cout << "Ingresa el tamaño del vector" << endl;

cin >> dim;
p = new int[dim];
for(int i = 0; i < dim; i++){

p[i] = i * i;
cout << p[i] << endl;
}
delete[] p;
➢ MATRICES DINAMICOS, para crear una matriz dinámica debemos de crear un doble
puntero y usamos 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.
Para crear un arreglo bidimensional el asunto no es tan simple como lo fue para el
arreglo de una dimensión (vectores), ya que lo siguiente no es permitido.
int m, n;
Capitulo IV Pág. 3
cin >> m >> n;
int *arreglo = new int[m][n]; // ¡tampoco funciona!
Para lograr crear la matriz bidimensional en memoria dinámica es necesario

comprender que la misma va a estar formada por dos partes: primero, un arreglo de
punteros y segundo, una serie de arreglos de elementos. Cada uno de los punteros del
primer arreglo va a apuntar a un arreglo de elementos. El nombre del arreglo
bidimensional es un puntero que apunta hacia el primer arreglo; por lo tanto, el
nombre de la matriz no va a ser simplemente un puntero hacia elementos, si no que
es un puntero hacia un arreglo de punteros, lo que significa que hay que declararlo
como un puntero hacia un puntero. Esta lógica puede extenderse a cualquier cantidad
de dimensiones.
La matriz del diagrama anterior la podemos ver como una matriz de 3 filas por 3
columnas. El asunto es que tanto los arreglos con los elementos como el arreglo de
punteros van a existir en memoria dinámica, por lo que hay que solicitar la memoria
respectiva.
int **arreglo = new int*[3];

for (int i = 0; i < 3; i++) {
arreglo[i] = new int[3];
}
Primero se solicita memoria para el arreglo de punteros y luego se solicita la memoria

para cada una de las filas de la matriz. En el ejemplo anterior, las dimensiones están
fijas en el código, pero estos valores pueden ser variables dado que se está declarando
todo en memoria dinámica. Entonces, volviendo a nuestra intención original, puede
hacerse algo como lo siguiente.
Capitulo IV Pág. 4
int m, n;
cin >> m >> n;
int **arreglo = new int*[m];
for (int i = 0; i < m; i++) {
arreglo[i] = new int[n];
}
Es importante recalcar que, cuando se solicita memoria dinámica, ésta no se encuentra

inicializada, por lo que los valores almacenados son indeterminados y podríamos
obtener cualquier valor.
Después de esa declaración es posible acceder a los elementos de la matriz mediante

dos índices, uno para seleccionar la "fila" y otro para la "columna". Si quisiéramos
asignar un valor inicial de cero a todos los elementos de la matriz anterior, debe
hacerse algo así:
for (int i = 0; i < m; i++) {

for (int j = 0; j < n; j++) {
arreglo[i][j] = 0;
}
}
Luego de ejecutar las operaciones requeridas con la matriz, se debe de liberar la
memoria de forma inversa a cómo fue solicitada o reservada, es decir, primero se
libera los elementos internos y luego el puntero principal.
// Elimino cada vector de la matriz

for (int i = 0; i < rows; i++) {
delete[] arreglo[i];
}
// Elimino el vector principal

delete[] arreglo;
Capitulo IV Pág. 5
III. ESTRUCTURAS DE DATOS
Anteriormente se había visto que una matriz es un conjunto de elemento de igual tipo.
Una estructura es un conjunto de elementos de distinto tipo.
struct inventario {
int nro;
int edad;
float talla;
};
Aquí se ha definido un tipo de dato de usuario compuesto por datos de distinto tipo. Las
variables del tipo definido se pueden declarar de la misma manera que otras variables y
a sus miembros componentes (en este caso, número, edad y talla) se puede acceder de
la siguiente manera:
inventario p3;
p3.nro = 12 // se usa el punto para referirnos
// a un miembro de la estructura
p3.edad = 28;
p3.talla = 1.80;
Otro ejemplo de tipo compuesto es la clase string. Las variables de este tipo pueden
lmacenar secuencias de caracteres, como palabras u oraciones.
Una primera diferencia con los tipos de datos fundamentales es que para declarar y
utilizar objetos (variables) de este tipo, el programa debe incluir el encabezado donde
se define el tipo dentro de la biblioteca estándar (encabezado <string>):
#include <iostream>
#include <string>
using namespace std;
int main ()
{
String stCadena;
Capitulo IV Pág. 6
mystring = "Es una cadena";
cout << stCadena;
return 0;
}
IV. LABORATORIO N° 1
Escriba un programa en C++ para declarar vectores y matrices dinámicas;
Capitulo IV Pág. 7

QT Capitulo 04

Cargado por

Copyright:

Formatos disponibles

QT Capitulo 04

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

QT Capitulo 04

Cargado por

Copyright:

Formatos disponibles

Programación C++ con las Librerías QT sobre entorno linux

CAPÍTULO No. 4: Estructura de control de flujos Duración: 4 Hrs

II. PUNTEROS DINAMICOS

Para usar vectores dinámicos necesitamos gestionar memoria dinámica. Si bien es

Siempre es recomendable liberar memoria para posteriormente no tener problemas

cout << "Ingresa el tamaño del vector" << endl;

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

Para lograr crear la matriz bidimensional en memoria dinámica es necesario

int **arreglo = new int*[3];

Primero se solicita memoria para el arreglo de punteros y luego se solicita la memoria

Es importante recalcar que, cuando se solicita memoria dinámica, ésta no se encuentra

Después de esa declaración es posible acceder a los elementos de la matriz mediante

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

// Elimino cada vector de la matriz

// Elimino el vector principal

Escriba un programa en C++ para declarar vectores y matrices dinámicas;

También podría gustarte

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.