La siguiente declaración: int **p permite crear las siguientes estructuras de datos en memoria: Verdadero Falso. Si la declaración del puntero anterior p se realiza como se muestra a continuación, entonces es creado como una variable residente en la pila de aplicación:
void f(){
int **p;
....
} Verdadero Falso. Una matriz declarada como int a[3][5] se almacena en una zona contigua de memoria. Verdadero Falso. Sea m1 una matriz declarada como int m1[10][20] y m2 un puntero declarado como int **m2 e iniciado mediante el código:
m2 = new int*[10]
for (int c=0; c < 10; ++c){
m2[c] = new int[20];
}
Entonces el elemento existente en la posición (3,7) se accede de igual manera con ambas estructuras de datos: m1[3][7], m2[3][7]. Verdadero Falso. El siguiente código presenta memory leaks:
int *p = new int[1000];
for(int c=0; c <=1000; ++c){
p[c] = 0;
} Verdadero Falso. El sigioente código presenta heap overflows:
int *p;
for(int c=0; c < 10; ++c){
p = new int[100];
} Verdadero Falso. Una plantilla de clase instanciable para el tipo T=int puede que no lo sea para el tipo T=MiClase; es decir, que una plantilla puede no aceptar cualquier tipo como parámetro. Verdadero Falso. A través del puntero int **m podemos manejar una matriz creada en memoria dinámica con un número de filas y columnas arbitrario. Verdadero Falso. Un vector dinámico es una estructura básica que puede ser utilizada en la implementación de asociaciones y composiciones múltiples cuando no hay restricciones o necesidades especiales en las mismas. Verdadero Falso. Un dato almacenado en un vector dinámico que permanece en dicha estructura de datos a lo largo de todo su ciclo de vida, nunca cambia su posición de memoria. Verdadero Falso. La siguiente definición de vector estático necesita de constructor copia y operador de asignación:
template<typename T> class MiVect{
int tama;
T *v;
public:
MiVect(int n){ v = new T[tama = n]; }
...
} Verdadero Falso. La clase VDinamico debe definir la operación [] para que funcione correctamente (se obvian las comprobaciones de rango):
T operator[](unsigned i){ return v[i]; } Verdadero Falso. Si se ha instanciado en la clase Biblioteca a Mivect (VDinamico) para implementar una realción de asociación con la clase Libro:
MiVect<Libro*> estante;
Entonces el destructor de Biblioteca debe entonces eliminar estante ejecutando: delete [] estante; Verdadero Falso. Es posible eliminar la posición de un vector dinámico en tiempo O(1) si no es necesario preservar el orden de los datos. Verdadero Falso. La implementación normal de un vector dinámico implementa una reducción del tamaño físico a la mitad cuando el tamaño lógico cae por debajo del tamañofisico/2. Verdadero Falso. El operador de asignación de la clase Matriz<T>::operator = debe siempre destruir la matriz destino de la asignación. Verdadero Falso. El operador de la clase Matriz<T>::operator += devuelve el objeto resultado por copia. Verdadero Falso. La implementación de conjuntos mediante vectores realiza la intersección en tiempo lineal. Verdadero Falso. El problema que poseen los conjuntos de bits es que el ID de un elemento debe ser un entero desde 0 hasta el tamaño del conjunto -1. Para convertirlo en un ID genérico se necesita otra EEDD. Verdadero Falso. Para almacenar 3841 datos en un conjunto de bits, debo crear un buffer de 480 bytes. Verdadero Falso. a.intersec(b+a) == a es correcto Verdadero Falso. El resultado de realizar esta operación:
char mascara = 1 << (500%8) es 0000100 Verdadero Falso. El tiempo para eliminar un dato en una posición arbitraria de una lista es lineal Verdadero Falso. El tiempo para eliminar un dato en una posición apuntada por un iterador es lineal Verdadero Falso. Para eliminar e insertar un dato en posiciones intermedias de una lista se necesita un puntero a la posición anterior al dato que se va a insertar/borrar. Verdadero Falso. Se puede realizar la operación merge_sort entre dos listas ordenadas en tiempo O(n+m), siendo n y m los tamaños respectivos de ambas listas Verdadero Falso. Un dato que permanece en una lista cambia su posición a veces al sufrir la lista inserciones y borrados. Verdadero Falso. Una lista doblemente enlazada permite realizar búsquedas binarias en tiempo O(log n) si los datos se encuentran ordenados Verdadero Falso. Iterar sobre un vector dinámico es siempre más rápido que sobre una lista enlazada (simple o doble) Verdadero Falso. El siguiente código inserta correctamente, en un caso genérico, un nuevo nodo apuntado por p por delante de la posición del nodo apuntado por q en una lista doblemente enlazada y circular:
p->siguiente = q;
p->anterior = q->anterior;
q->anterior = p;
p->anterior->siguiente = q; Verdadero Falso. Transferir todos los nodos de una lista doblemente enlazada l1 al final de la lista doblemente enlazada l2 requiere tiempo O(1), quedando l1 vacía. Verdadero Falso. La siguiente implementación del constructor copia de una lista enlazada no contiene errores:
ListaEnlazada<T>::ListaEnlazada(const ListaEnlazada<T>& lista){
cabecera = lista.cabecera;
cola = lista.cola;
} Verdadero Falso. La implementación de las matrices dispersas es completamente distinta de las matrices ordinarias, estando basada en el uso de listas enlazadas. Verdadero Falso.
|